You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2022/06/22 07:41:14 UTC
[plc4x] branch develop updated: refactor(codegen/plc4go): introduced a ${type.name}Exactly interface for exact type matches
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 58f08fcc70 refactor(codegen/plc4go): introduced a ${type.name}Exactly interface for exact type matches
58f08fcc70 is described below
commit 58f08fcc7087cd8760e25904548886de008a9a77
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Wed Jun 22 09:41:03 2022 +0200
refactor(codegen/plc4go): introduced a ${type.name}Exactly interface for exact type matches
---
.../resources/templates/go/complex-type-template.go.ftlh | 14 ++++++++++++--
.../readwrite/model/CIPEncapsulationConnectionRequest.go | 10 ++++++++++
.../readwrite/model/CIPEncapsulationConnectionResponse.go | 10 ++++++++++
.../abeth/readwrite/model/CIPEncapsulationPacket.go | 14 ++++++++++++--
.../abeth/readwrite/model/CIPEncapsulationReadRequest.go | 10 ++++++++++
.../abeth/readwrite/model/CIPEncapsulationReadResponse.go | 10 ++++++++++
.../abeth/readwrite/model/DF1CommandRequestMessage.go | 10 ++++++++++
.../DF1CommandResponseMessageProtectedTypedLogicalRead.go | 10 ++++++++++
.../protocols/abeth/readwrite/model/DF1RequestCommand.go | 14 ++++++++++++--
.../protocols/abeth/readwrite/model/DF1RequestMessage.go | 14 ++++++++++++--
.../readwrite/model/DF1RequestProtectedTypedLogicalRead.go | 10 ++++++++++
.../protocols/abeth/readwrite/model/DF1ResponseMessage.go | 14 ++++++++++++--
.../ads/readwrite/model/AdsAddDeviceNotificationRequest.go | 10 ++++++++++
.../readwrite/model/AdsAddDeviceNotificationResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsData.go | 14 ++++++++++++--
.../readwrite/model/AdsDeleteDeviceNotificationRequest.go | 10 ++++++++++
.../readwrite/model/AdsDeleteDeviceNotificationResponse.go | 10 ++++++++++
.../ads/readwrite/model/AdsDeviceNotificationRequest.go | 10 ++++++++++
.../ads/readwrite/model/AdsDeviceNotificationResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsInvalidRequest.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsInvalidResponse.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsMultiRequestItem.go | 14 ++++++++++++--
.../ads/readwrite/model/AdsMultiRequestItemRead.go | 10 ++++++++++
.../ads/readwrite/model/AdsMultiRequestItemReadWrite.go | 10 ++++++++++
.../ads/readwrite/model/AdsMultiRequestItemWrite.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsNotificationSample.go | 10 ++++++++++
.../ads/readwrite/model/AdsReadDeviceInfoRequest.go | 10 ++++++++++
.../ads/readwrite/model/AdsReadDeviceInfoResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsReadRequest.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsReadResponse.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsReadStateRequest.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsReadStateResponse.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsReadWriteRequest.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AdsReadWriteResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsStampHeader.go | 10 ++++++++++
.../ads/readwrite/model/AdsWriteControlRequest.go | 10 ++++++++++
.../ads/readwrite/model/AdsWriteControlResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsWriteRequest.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AdsWriteResponse.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AmsNetId.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AmsPacket.go | 10 ++++++++++
.../ads/readwrite/model/AmsSerialAcknowledgeFrame.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AmsSerialFrame.go | 10 ++++++++++
.../protocols/ads/readwrite/model/AmsSerialResetFrame.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/AmsTCPPacket.go | 10 ++++++++++
plc4go/protocols/ads/readwrite/model/State.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/APDU.go | 14 ++++++++++++--
plc4go/protocols/bacnetip/readwrite/model/APDUAbort.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/APDUComplexAck.go | 10 ++++++++++
.../bacnetip/readwrite/model/APDUConfirmedRequest.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/APDUError.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/APDUReject.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/APDUSegmentAck.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/APDUSimpleAck.go | 10 ++++++++++
.../bacnetip/readwrite/model/APDUUnconfirmedRequest.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/APDUUnknown.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAbortReasonTagged.go | 10 ++++++++++
.../model/BACnetAccessAuthenticationFactorDisableTagged.go | 10 ++++++++++
.../model/BACnetAccessCredentialDisableReasonTagged.go | 10 ++++++++++
.../readwrite/model/BACnetAccessCredentialDisableTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAccessEventTagged.go | 10 ++++++++++
.../readwrite/model/BACnetAccessPassbackModeTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetAccessRule.go | 10 ++++++++++
.../model/BACnetAccessRuleLocationSpecifierTagged.go | 10 ++++++++++
.../model/BACnetAccessRuleTimeRangeSpecifierTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAccessThreatLevel.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAccessUserTypeTagged.go | 10 ++++++++++
.../model/BACnetAccessZoneOccupancyStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAccumulatorRecord.go | 10 ++++++++++
.../BACnetAccumulatorRecordAccumulatorStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetActionCommand.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetActionList.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetActionTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BACnetAddress.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAddressBinding.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAddressEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTag.go | 14 ++++++++++++--
.../readwrite/model/BACnetApplicationTagBitString.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagCharacterString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTagDate.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTagDouble.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagEnumerated.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTagNull.go | 10 ++++++++++
.../model/BACnetApplicationTagObjectIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagOctetString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTagReal.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagSignedInteger.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetApplicationTagTime.go | 10 ++++++++++
.../readwrite/model/BACnetApplicationTagUnsignedInteger.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAssignedAccessRights.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAssignedLandingCalls.go | 10 ++++++++++
.../model/BACnetAssignedLandingCallsLandingCallsList.go | 10 ++++++++++
.../BACnetAssignedLandingCallsLandingCallsListEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAuthenticationFactor.go | 10 ++++++++++
.../readwrite/model/BACnetAuthenticationFactorEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetAuthenticationFactorFormat.go | 10 ++++++++++
.../model/BACnetAuthenticationFactorTypeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetAuthenticationPolicy.go | 10 ++++++++++
.../readwrite/model/BACnetAuthenticationPolicyList.go | 10 ++++++++++
.../readwrite/model/BACnetAuthenticationPolicyListEntry.go | 10 ++++++++++
.../readwrite/model/BACnetAuthenticationStatusTagged.go | 10 ++++++++++
.../readwrite/model/BACnetAuthorizationExemptionTagged.go | 10 ++++++++++
.../readwrite/model/BACnetAuthorizationModeTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetBDTEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetBackupStateTagged.go | 10 ++++++++++
.../readwrite/model/BACnetBinaryLightingPVTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetBinaryPVTagged.go | 10 ++++++++++
.../readwrite/model/BACnetCOVMultipleSubscription.go | 10 ++++++++++
...ltipleSubscriptionListOfCovSubscriptionSpecification.go | 10 ++++++++++
...eSubscriptionListOfCovSubscriptionSpecificationEntry.go | 10 ++++++++++
...CovSubscriptionSpecificationEntryListOfCovReferences.go | 10 ++++++++++
...bscriptionSpecificationEntryListOfCovReferencesEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetCOVSubscription.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetCalendarEntry.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetCalendarEntryDate.go | 10 ++++++++++
.../readwrite/model/BACnetCalendarEntryDateRange.go | 10 ++++++++++
.../readwrite/model/BACnetCalendarEntryEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetCalendarEntryWeekNDay.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValue.go | 14 ++++++++++++--
.../readwrite/model/BACnetChannelValueBitString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetChannelValueCharacterString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueDate.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueDouble.go | 10 ++++++++++
.../readwrite/model/BACnetChannelValueEnumerated.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueInteger.go | 10 ++++++++++
.../readwrite/model/BACnetChannelValueLightingCommand.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueNull.go | 10 ++++++++++
.../readwrite/model/BACnetChannelValueObjectidentifier.go | 10 ++++++++++
.../readwrite/model/BACnetChannelValueOctetString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueReal.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetChannelValueUnsigned.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetClientCOV.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetClientCOVNone.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetClientCOVObject.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetClosingTag.go | 10 ++++++++++
.../readwrite/model/BACnetConfirmedServiceRequest.go | 14 ++++++++++++--
.../model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestAddListElement.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestAtomicReadFile.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestAtomicReadFileRecord.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestAtomicReadFileStream.go | 10 ++++++++++
...tConfirmedServiceRequestAtomicReadFileStreamOrRecord.go | 14 ++++++++++++--
.../model/BACnetConfirmedServiceRequestAtomicWriteFile.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestAuthenticate.go | 10 ++++++++++
...ACnetConfirmedServiceRequestConfirmedCOVNotification.go | 10 ++++++++++
...firmedServiceRequestConfirmedCOVNotificationMultiple.go | 10 ++++++++++
...netConfirmedServiceRequestConfirmedEventNotification.go | 10 ++++++++++
...ACnetConfirmedServiceRequestConfirmedPrivateTransfer.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestConfirmedTextMessage.go | 10 ++++++++++
...firmedServiceRequestConfirmedTextMessageMessageClass.go | 14 ++++++++++++--
...viceRequestConfirmedTextMessageMessageClassCharacter.go | 10 ++++++++++
...erviceRequestConfirmedTextMessageMessageClassNumeric.go | 10 ++++++++++
...viceRequestConfirmedTextMessageMessagePriorityTagged.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestConfirmedUnknown.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestCreateObject.go | 10 ++++++++++
...etConfirmedServiceRequestCreateObjectObjectSpecifier.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestDeleteObject.go | 10 ++++++++++
...netConfirmedServiceRequestDeviceCommunicationControl.go | 10 ++++++++++
...RequestDeviceCommunicationControlEnableDisableTagged.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestGetEnrollmentSummary.go | 10 ++++++++++
...questGetEnrollmentSummaryAcknowledgementFilterTagged.go | 10 ++++++++++
...iceRequestGetEnrollmentSummaryEventStateFilterTagged.go | 10 ++++++++++
...rmedServiceRequestGetEnrollmentSummaryPriorityFilter.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestGetEventInformation.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestLifeSafetyOperation.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestReadProperty.go | 10 ++++++++++
...BACnetConfirmedServiceRequestReadPropertyConditional.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestReadPropertyMultiple.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestReadRange.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestReadRangeRange.go | 14 ++++++++++++--
...ACnetConfirmedServiceRequestReadRangeRangeByPosition.go | 10 ++++++++++
...onfirmedServiceRequestReadRangeRangeBySequenceNumber.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestReadRangeRangeByTime.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestReinitializeDevice.go | 10 ++++++++++
...stReinitializeDeviceReinitializedStateOfDeviceTagged.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestRemoveListElement.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestRequestKey.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestSubscribeCOV.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestSubscribeCOVProperty.go | 10 ++++++++++
...tConfirmedServiceRequestSubscribeCOVPropertyMultiple.go | 10 ++++++++++
...VPropertyMultipleListOfCovSubscriptionSpecifications.go | 10 ++++++++++
...pertyMultipleListOfCovSubscriptionSpecificationsList.go | 10 ++++++++++
...MultipleListOfCovSubscriptionSpecificationsReference.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestVTClose.go | 10 ++++++++++
.../readwrite/model/BACnetConfirmedServiceRequestVTData.go | 10 ++++++++++
.../readwrite/model/BACnetConfirmedServiceRequestVTOpen.go | 10 ++++++++++
.../model/BACnetConfirmedServiceRequestWriteProperty.go | 10 ++++++++++
.../BACnetConfirmedServiceRequestWritePropertyMultiple.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedData.go | 14 ++++++++++++--
.../readwrite/model/BACnetConstructedDataAPDULength.go | 10 ++++++++++
.../model/BACnetConstructedDataAPDUSegmentTimeout.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAPDUTimeout.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAbsenteeLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAcceptedModes.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessAlarmEvents.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessCredentialAll.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessDoorAlarmValues.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessDoorAll.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessDoorFaultValues.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessDoorPresentValue.go | 10 ++++++++++
.../BACnetConstructedDataAccessDoorRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessDoors.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessEvent.go | 10 ++++++++++
...BACnetConstructedDataAccessEventAuthenticationFactor.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessEventCredential.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessEventTag.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessEventTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessPointAll.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessRightsAll.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessTransactionEvents.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessUserAll.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessZoneAdjustValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAccessZoneAlarmValues.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccessZoneAll.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccompaniment.go | 10 ++++++++++
.../model/BACnetConstructedDataAccompanimentTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAccumulatorAll.go | 10 ++++++++++
.../BACnetConstructedDataAccumulatorFaultHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAccumulatorFaultLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAccumulatorHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAccumulatorLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAccumulatorMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAccumulatorMinPresValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAckRequired.go | 10 ++++++++++
.../model/BACnetConstructedDataAckedTransitions.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAction.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataActionText.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataActivationTime.go | 10 ++++++++++
.../BACnetConstructedDataActiveAuthenticationPolicy.go | 10 ++++++++++
.../BACnetConstructedDataActiveCOVMultipleSubscriptions.go | 10 ++++++++++
.../model/BACnetConstructedDataActiveCOVSubscriptions.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataActiveText.go | 10 ++++++++++
.../model/BACnetConstructedDataActiveVTSessions.go | 10 ++++++++++
.../model/BACnetConstructedDataActualShedLevel.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAdjustValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAlarmValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataAlertEnrollmentAll.go | 10 ++++++++++
.../BACnetConstructedDataAlertEnrollmentPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAlignIntervals.go | 10 ++++++++++
.../model/BACnetConstructedDataAllWritesSuccessful.go | 10 ++++++++++
.../model/BACnetConstructedDataAllowGroupDelayInhibit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAnalogInputAll.go | 10 ++++++++++
.../BACnetConstructedDataAnalogInputFaultHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogInputFaultLowLimit.go | 10 ++++++++++
.../BACnetConstructedDataAnalogInputInterfaceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogInputMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogInputPresentValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogOutputAll.go | 10 ++++++++++
.../BACnetConstructedDataAnalogOutputInterfaceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogOutputMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogOutputPresentValue.go | 10 ++++++++++
.../BACnetConstructedDataAnalogOutputRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAnalogValueAll.go | 10 ++++++++++
.../BACnetConstructedDataAnalogValueFaultHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogValueFaultLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogValueMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataAnalogValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataAnalogValueRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataApplicationSoftwareVersion.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataArchive.go | 10 ++++++++++
.../model/BACnetConstructedDataAssignedAccessRights.go | 10 ++++++++++
.../model/BACnetConstructedDataAssignedLandingCalls.go | 10 ++++++++++
.../model/BACnetConstructedDataAttemptedSamples.go | 10 ++++++++++
.../model/BACnetConstructedDataAuthenticationFactors.go | 10 ++++++++++
.../model/BACnetConstructedDataAuthenticationPolicyList.go | 10 ++++++++++
.../BACnetConstructedDataAuthenticationPolicyNames.go | 10 ++++++++++
.../model/BACnetConstructedDataAuthenticationStatus.go | 10 ++++++++++
.../model/BACnetConstructedDataAuthorizationExemptions.go | 10 ++++++++++
.../model/BACnetConstructedDataAuthorizationMode.go | 10 ++++++++++
.../model/BACnetConstructedDataAutoSlaveDiscovery.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAverageValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataAveragingAll.go | 10 ++++++++++
.../model/BACnetConstructedDataBACnetIPGlobalAddress.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBACnetIPMode.go | 10 ++++++++++
.../model/BACnetConstructedDataBACnetIPMulticastAddress.go | 10 ++++++++++
.../model/BACnetConstructedDataBACnetIPNATTraversal.go | 10 ++++++++++
.../model/BACnetConstructedDataBACnetIPUDPPort.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBACnetIPv6Mode.go | 10 ++++++++++
.../BACnetConstructedDataBACnetIPv6MulticastAddress.go | 10 ++++++++++
.../model/BACnetConstructedDataBACnetIPv6UDPPort.go | 10 ++++++++++
.../BACnetConstructedDataBBMDAcceptFDRegistrations.go | 10 ++++++++++
.../BACnetConstructedDataBBMDBroadcastDistributionTable.go | 10 ++++++++++
.../model/BACnetConstructedDataBBMDForeignDeviceTable.go | 10 ++++++++++
.../model/BACnetConstructedDataBackupAndRestoreState.go | 10 ++++++++++
.../model/BACnetConstructedDataBackupFailureTimeout.go | 10 ++++++++++
.../model/BACnetConstructedDataBackupPreparationTime.go | 10 ++++++++++
.../model/BACnetConstructedDataBaseDeviceSecurityPolicy.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBelongsTo.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataBias.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBinaryInputAll.go | 10 ++++++++++
.../BACnetConstructedDataBinaryInputInterfaceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataBinaryInputPresentValue.go | 10 ++++++++++
.../model/BACnetConstructedDataBinaryLightingOutputAll.go | 10 ++++++++++
...CnetConstructedDataBinaryLightingOutputFeedbackValue.go | 10 ++++++++++
...ACnetConstructedDataBinaryLightingOutputPresentValue.go | 10 ++++++++++
...ConstructedDataBinaryLightingOutputRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataBinaryOutputAll.go | 10 ++++++++++
.../BACnetConstructedDataBinaryOutputFeedbackValue.go | 10 ++++++++++
.../BACnetConstructedDataBinaryOutputInterfaceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataBinaryOutputPresentValue.go | 10 ++++++++++
.../BACnetConstructedDataBinaryOutputRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBinaryValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataBinaryValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataBinaryValueRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBitMask.go | 10 ++++++++++
.../BACnetConstructedDataBitStringValueAlarmValues.go | 10 ++++++++++
.../BACnetConstructedDataBitStringValuePresentValue.go | 10 ++++++++++
...BACnetConstructedDataBitStringValueRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBitText.go | 10 ++++++++++
.../model/BACnetConstructedDataBitstringValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataBlinkWarnEnable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataBufferSize.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCOVIncrement.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCOVPeriod.go | 10 ++++++++++
.../BACnetConstructedDataCOVResubscriptionInterval.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCOVUPeriod.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCOVURecipients.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCalendarAll.go | 10 ++++++++++
.../model/BACnetConstructedDataCalendarPresentValue.go | 10 ++++++++++
.../model/BACnetConstructedDataCarAssignedDirection.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarDoorCommand.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarDoorStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarDoorText.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarDoorZone.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarDriveStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarLoad.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarLoadUnits.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarMode.go | 10 ++++++++++
.../model/BACnetConstructedDataCarMovingDirection.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCarPosition.go | 10 ++++++++++
.../model/BACnetConstructedDataChangeOfStateCount.go | 10 ++++++++++
.../model/BACnetConstructedDataChangeOfStateTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataChangesPending.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataChannelAll.go | 10 ++++++++++
...ConstructedDataChannelListOfObjectPropertyReferences.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataChannelNumber.go | 10 ++++++++++
.../model/BACnetConstructedDataChannelPresentValue.go | 10 ++++++++++
...BACnetConstructedDataCharacterStringValueAlarmValues.go | 10 ++++++++++
...BACnetConstructedDataCharacterStringValueFaultValues.go | 10 ++++++++++
...ACnetConstructedDataCharacterStringValuePresentValue.go | 10 ++++++++++
...ConstructedDataCharacterStringValueRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataCharacterstringValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataClientCOVIncrement.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCommand.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCommandAction.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCommandAll.go | 10 ++++++++++
.../model/BACnetConstructedDataCommandTimeArray.go | 10 ++++++++++
.../model/BACnetConstructedDataConfigurationFiles.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataControlGroups.go | 10 ++++++++++
.../BACnetConstructedDataControlledVariableReference.go | 10 ++++++++++
.../model/BACnetConstructedDataControlledVariableUnits.go | 10 ++++++++++
.../model/BACnetConstructedDataControlledVariableValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataCount.go | 10 ++++++++++
.../model/BACnetConstructedDataCountBeforeChange.go | 10 ++++++++++
.../model/BACnetConstructedDataCountChangeTime.go | 10 ++++++++++
.../model/BACnetConstructedDataCredentialDataInputAll.go | 10 ++++++++++
...BACnetConstructedDataCredentialDataInputPresentValue.go | 10 ++++++++++
.../BACnetConstructedDataCredentialDataInputUpdateTime.go | 10 ++++++++++
.../model/BACnetConstructedDataCredentialDisable.go | 10 ++++++++++
.../model/BACnetConstructedDataCredentialStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataCredentials.go | 10 ++++++++++
.../model/BACnetConstructedDataCredentialsInZone.go | 10 ++++++++++
.../model/BACnetConstructedDataCurrentCommandPriority.go | 10 ++++++++++
.../model/BACnetConstructedDataDatabaseRevision.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDateList.go | 10 ++++++++++
.../BACnetConstructedDataDatePatternValuePresentValue.go | 10 ++++++++++
...CnetConstructedDataDatePatternValueRelinquishDefault.go | 10 ++++++++++
...ACnetConstructedDataDateTimePatternValuePresentValue.go | 10 ++++++++++
...ConstructedDataDateTimePatternValueRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataDateTimeValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataDateTimeValueRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDateValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataDateValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataDateValueRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataDatepatternValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataDatetimeValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataDatetimepatternValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataDaylightSavingsStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDaysRemaining.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDeadband.go | 10 ++++++++++
.../model/BACnetConstructedDataDefaultFadeTime.go | 10 ++++++++++
.../model/BACnetConstructedDataDefaultRampRate.go | 10 ++++++++++
.../model/BACnetConstructedDataDefaultStepIncrement.go | 10 ++++++++++
.../BACnetConstructedDataDefaultSubordinateRelationship.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDefaultTimeout.go | 10 ++++++++++
.../model/BACnetConstructedDataDeployedProfileLocation.go | 10 ++++++++++
.../model/BACnetConstructedDataDerivativeConstant.go | 10 ++++++++++
.../model/BACnetConstructedDataDerivativeConstantUnits.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDescription.go | 10 ++++++++++
.../model/BACnetConstructedDataDescriptionOfHalt.go | 10 ++++++++++
.../model/BACnetConstructedDataDeviceAddressBinding.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDeviceAll.go | 10 ++++++++++
.../model/BACnetConstructedDataDeviceMaxInfoFrames.go | 10 ++++++++++
.../model/BACnetConstructedDataDeviceMaxMaster.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDeviceType.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDirectReading.go | 10 ++++++++++
.../model/BACnetConstructedDataDistributionKeyRevision.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDoNotHide.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDoorAlarmState.go | 10 ++++++++++
.../model/BACnetConstructedDataDoorExtendedPulseTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDoorMembers.go | 10 ++++++++++
.../model/BACnetConstructedDataDoorOpenTooLongTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDoorPulseTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDoorStatus.go | 10 ++++++++++
.../model/BACnetConstructedDataDoorUnlockDelayTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataDutyWindow.go | 10 ++++++++++
.../model/BACnetConstructedDataEffectivePeriod.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEgressActive.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEgressTime.go | 10 ++++++++++
.../model/BACnetConstructedDataElapsedActiveTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataElement.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataElevatorGroup.go | 10 ++++++++++
.../model/BACnetConstructedDataElevatorGroupAll.go | 10 ++++++++++
.../BACnetConstructedDataElevatorGroupGroupMembers.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEnable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEnergyMeter.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEnergyMeterRef.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEntryPoints.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataErrorLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEscalatorAll.go | 10 ++++++++++
.../model/BACnetConstructedDataEscalatorFaultSignals.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEscalatorMode.go | 10 ++++++++++
.../model/BACnetConstructedDataEventAlgorithmInhibit.go | 10 ++++++++++
.../model/BACnetConstructedDataEventAlgorithmInhibitRef.go | 10 ++++++++++
.../model/BACnetConstructedDataEventDetectionEnable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEventEnable.go | 10 ++++++++++
.../model/BACnetConstructedDataEventEnrollmentAll.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEventLogAll.go | 10 ++++++++++
.../model/BACnetConstructedDataEventLogLogBuffer.go | 10 ++++++++++
.../model/BACnetConstructedDataEventMessageTexts.go | 10 ++++++++++
.../model/BACnetConstructedDataEventMessageTextsConfig.go | 10 ++++++++++
.../model/BACnetConstructedDataEventParameters.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEventState.go | 10 ++++++++++
.../model/BACnetConstructedDataEventTimeStamps.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataEventType.go | 10 ++++++++++
.../model/BACnetConstructedDataExceptionSchedule.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataExecutionDelay.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataExitPoints.go | 10 ++++++++++
.../model/BACnetConstructedDataExpectedShedLevel.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataExpirationTime.go | 10 ++++++++++
.../model/BACnetConstructedDataExtendedTimeEnable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFDBBMDAddress.go | 10 ++++++++++
.../model/BACnetConstructedDataFDSubscriptionLifetime.go | 10 ++++++++++
.../model/BACnetConstructedDataFailedAttemptEvents.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFailedAttempts.go | 10 ++++++++++
.../model/BACnetConstructedDataFailedAttemptsTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFaultHighLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFaultLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataFaultParameters.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFaultSignals.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFaultType.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFaultValues.go | 10 ++++++++++
.../model/BACnetConstructedDataFileAccessMethod.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFileAll.go | 10 ++++++++++
.../model/BACnetConstructedDataFileRecordCount.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFileSize.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFileType.go | 10 ++++++++++
.../model/BACnetConstructedDataFirmwareRevision.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataFloorText.go | 10 ++++++++++
.../model/BACnetConstructedDataFullDutyBaseline.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataGlobalGroupAll.go | 10 ++++++++++
.../model/BACnetConstructedDataGlobalGroupGroupMembers.go | 10 ++++++++++
.../model/BACnetConstructedDataGlobalGroupPresentValue.go | 10 ++++++++++
.../model/BACnetConstructedDataGlobalIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataGroupAll.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataGroupID.go | 10 ++++++++++
.../model/BACnetConstructedDataGroupMemberNames.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataGroupMembers.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataGroupMode.go | 10 ++++++++++
.../model/BACnetConstructedDataGroupPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataHighLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataHigherDeck.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPAddress.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPDHCPEnable.go | 10 ++++++++++
.../model/BACnetConstructedDataIPDHCPLeaseTime.go | 10 ++++++++++
.../model/BACnetConstructedDataIPDHCPLeaseTimeRemaining.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPDHCPServer.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPDNSServer.go | 10 ++++++++++
.../model/BACnetConstructedDataIPDefaultGateway.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPSubnetMask.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPv6Address.go | 10 ++++++++++
.../model/BACnetConstructedDataIPv6AutoAddressingEnable.go | 10 ++++++++++
.../model/BACnetConstructedDataIPv6DHCPLeaseTime.go | 10 ++++++++++
.../BACnetConstructedDataIPv6DHCPLeaseTimeRemaining.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPv6DHCPServer.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPv6DNSServer.go | 10 ++++++++++
.../model/BACnetConstructedDataIPv6DefaultGateway.go | 10 ++++++++++
.../model/BACnetConstructedDataIPv6PrefixLength.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIPv6ZoneIndex.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInProcess.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInProgress.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInactiveText.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInitialTimeout.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInputReference.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInstallationID.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataInstanceOf.go | 10 ++++++++++
.../model/BACnetConstructedDataInstantaneousPower.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueCOVIncrement.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueDeadband.go | 10 ++++++++++
.../BACnetConstructedDataIntegerValueFaultHighLimit.go | 10 ++++++++++
.../BACnetConstructedDataIntegerValueFaultLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueLowLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueMinPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataIntegerValueRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegerValueResolution.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegralConstant.go | 10 ++++++++++
.../model/BACnetConstructedDataIntegralConstantUnits.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataIntervalOffset.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataIsUTC.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataKeySets.go | 10 ++++++++++
.../model/BACnetConstructedDataLandingCallControl.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLandingCalls.go | 10 ++++++++++
.../model/BACnetConstructedDataLandingDoorStatus.go | 10 ++++++++++
.../model/BACnetConstructedDataLargeAnalogValueAll.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueCOVIncrement.go | 10 ++++++++++
.../model/BACnetConstructedDataLargeAnalogValueDeadband.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueFaultHighLimit.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueFaultLowLimit.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueHighLimit.go | 10 ++++++++++
.../model/BACnetConstructedDataLargeAnalogValueLowLimit.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueMaxPresValue.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueMinPresValue.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValuePresentValue.go | 10 ++++++++++
...CnetConstructedDataLargeAnalogValueRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataLargeAnalogValueResolution.go | 10 ++++++++++
.../model/BACnetConstructedDataLastAccessEvent.go | 10 ++++++++++
.../model/BACnetConstructedDataLastAccessPoint.go | 10 ++++++++++
.../model/BACnetConstructedDataLastCommandTime.go | 10 ++++++++++
.../model/BACnetConstructedDataLastCredentialAdded.go | 10 ++++++++++
.../model/BACnetConstructedDataLastCredentialAddedTime.go | 10 ++++++++++
.../model/BACnetConstructedDataLastCredentialRemoved.go | 10 ++++++++++
.../BACnetConstructedDataLastCredentialRemovedTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLastKeyServer.go | 10 ++++++++++
.../model/BACnetConstructedDataLastNotifyRecord.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLastPriority.go | 10 ++++++++++
.../model/BACnetConstructedDataLastRestartReason.go | 10 ++++++++++
.../model/BACnetConstructedDataLastRestoreTime.go | 10 ++++++++++
.../model/BACnetConstructedDataLastStateChange.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLastUseTime.go | 10 ++++++++++
.../model/BACnetConstructedDataLifeSafetyAlarmValues.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyPointAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataLifeSafetyPointAll.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyPointFaultValues.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyPointPresentValue.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyZoneAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataLifeSafetyZoneAll.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyZoneFaultValues.go | 10 ++++++++++
...CnetConstructedDataLifeSafetyZoneMaintenanceRequired.go | 10 ++++++++++
.../BACnetConstructedDataLifeSafetyZonePresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLiftAll.go | 10 ++++++++++
.../model/BACnetConstructedDataLiftFaultSignals.go | 10 ++++++++++
.../model/BACnetConstructedDataLightingCommand.go | 10 ++++++++++
.../BACnetConstructedDataLightingCommandDefaultPriority.go | 10 ++++++++++
.../model/BACnetConstructedDataLightingOutputAll.go | 10 ++++++++++
.../BACnetConstructedDataLightingOutputFeedbackValue.go | 10 ++++++++++
.../BACnetConstructedDataLightingOutputPresentValue.go | 10 ++++++++++
...BACnetConstructedDataLightingOutputRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataLightingOutputTrackingValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLimitEnable.go | 10 ++++++++++
.../model/BACnetConstructedDataLimitMonitoringInterval.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLinkSpeed.go | 10 ++++++++++
.../model/BACnetConstructedDataLinkSpeedAutonegotiate.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLinkSpeeds.go | 10 ++++++++++
.../model/BACnetConstructedDataListOfGroupMembers.go | 10 ++++++++++
.../BACnetConstructedDataListOfObjectPropertyReferences.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoadControlAll.go | 10 ++++++++++
.../model/BACnetConstructedDataLoadControlPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLocalDate.go | 10 ++++++++++
.../model/BACnetConstructedDataLocalForwardingOnly.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLocalTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLocation.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLockStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLockout.go | 10 ++++++++++
.../model/BACnetConstructedDataLockoutRelinquishTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLogBuffer.go | 10 ++++++++++
.../model/BACnetConstructedDataLogDeviceObjectProperty.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLogInterval.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoggingObject.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoggingRecord.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoggingType.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoopAction.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLoopAll.go | 10 ++++++++++
.../model/BACnetConstructedDataLoopPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLowDiffLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLowLimit.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataLowerDeck.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMACAddress.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMachineRoomID.go | 10 ++++++++++
.../model/BACnetConstructedDataMaintenanceRequired.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMakingCarCall.go | 10 ++++++++++
.../BACnetConstructedDataManipulatedVariableReference.go | 10 ++++++++++
.../BACnetConstructedDataManualSlaveAddressBinding.go | 10 ++++++++++
.../model/BACnetConstructedDataMaskedAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataMaxAPDULengthAccepted.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaxActualValue.go | 10 ++++++++++
.../model/BACnetConstructedDataMaxFailedAttempts.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaxInfoFrames.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaxMaster.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataMaxSegmentsAccepted.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaximumOutput.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMaximumValue.go | 10 ++++++++++
.../model/BACnetConstructedDataMaximumValueTimestamp.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMemberOf.go | 10 ++++++++++
.../model/BACnetConstructedDataMemberStatusFlags.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMembers.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinActualValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinPresValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinimumOffTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinimumOnTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinimumOutput.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMinimumValue.go | 10 ++++++++++
.../model/BACnetConstructedDataMinimumValueTimestamp.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataMode.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataModelName.go | 10 ++++++++++
.../model/BACnetConstructedDataModificationDate.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateInputAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataMultiStateInputAll.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateInputFaultValues.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateInputInterfaceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataMultiStateOutputAll.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateOutputFeedbackValue.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateOutputInterfaceValue.go | 10 ++++++++++
...CnetConstructedDataMultiStateOutputRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateValueAlarmValues.go | 10 ++++++++++
.../model/BACnetConstructedDataMultiStateValueAll.go | 10 ++++++++++
.../BACnetConstructedDataMultiStateValueFaultValues.go | 10 ++++++++++
...ACnetConstructedDataMultiStateValueRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataMusterPoint.go | 10 ++++++++++
.../model/BACnetConstructedDataNegativeAccessRules.go | 10 ++++++++++
.../BACnetConstructedDataNetworkAccessSecurityPolicies.go | 10 ++++++++++
.../model/BACnetConstructedDataNetworkInterfaceName.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNetworkNumber.go | 10 ++++++++++
.../model/BACnetConstructedDataNetworkNumberQuality.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNetworkPortAll.go | 10 ++++++++++
.../model/BACnetConstructedDataNetworkPortMaxInfoFrames.go | 10 ++++++++++
.../model/BACnetConstructedDataNetworkPortMaxMaster.go | 10 ++++++++++
.../model/BACnetConstructedDataNetworkSecurityAll.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNetworkType.go | 10 ++++++++++
.../model/BACnetConstructedDataNextStoppingFloor.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNodeSubtype.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNodeType.go | 10 ++++++++++
.../model/BACnetConstructedDataNotificationClass.go | 10 ++++++++++
.../model/BACnetConstructedDataNotificationClassAll.go | 10 ++++++++++
.../model/BACnetConstructedDataNotificationForwarderAll.go | 10 ++++++++++
.../model/BACnetConstructedDataNotificationThreshold.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNotifyType.go | 10 ++++++++++
.../model/BACnetConstructedDataNumberOfAPDURetries.go | 10 ++++++++++
.../BACnetConstructedDataNumberOfAuthenticationPolicies.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataNumberOfStates.go | 10 ++++++++++
.../model/BACnetConstructedDataObjectIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataObjectList.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataObjectName.go | 10 ++++++++++
.../model/BACnetConstructedDataObjectPropertyReference.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataObjectType.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataOccupancyCount.go | 10 ++++++++++
.../model/BACnetConstructedDataOccupancyCountAdjust.go | 10 ++++++++++
.../model/BACnetConstructedDataOccupancyCountEnable.go | 10 ++++++++++
.../model/BACnetConstructedDataOccupancyLowerLimit.go | 10 ++++++++++
.../BACnetConstructedDataOccupancyLowerLimitEnforced.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataOccupancyState.go | 10 ++++++++++
.../model/BACnetConstructedDataOccupancyUpperLimit.go | 10 ++++++++++
.../BACnetConstructedDataOccupancyUpperLimitEnforced.go | 10 ++++++++++
.../BACnetConstructedDataOctetStringValuePresentValue.go | 10 ++++++++++
...CnetConstructedDataOctetStringValueRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataOctetstringValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataOperationDirection.go | 10 ++++++++++
.../model/BACnetConstructedDataOperationExpected.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataOptional.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataOutOfService.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataOutputUnits.go | 10 ++++++++++
.../model/BACnetConstructedDataPacketReorderTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPassbackMode.go | 10 ++++++++++
.../model/BACnetConstructedDataPassbackTimeout.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPassengerAlarm.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPolarity.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPortFilter.go | 10 ++++++++++
.../model/BACnetConstructedDataPositiveAccessRules.go | 10 ++++++++++
.../model/BACnetConstructedDataPositiveIntegerValueAll.go | 10 ++++++++++
...ACnetConstructedDataPositiveIntegerValueCOVIncrement.go | 10 ++++++++++
.../BACnetConstructedDataPositiveIntegerValueDeadband.go | 10 ++++++++++
...netConstructedDataPositiveIntegerValueFaultHighLimit.go | 10 ++++++++++
...CnetConstructedDataPositiveIntegerValueFaultLowLimit.go | 10 ++++++++++
.../BACnetConstructedDataPositiveIntegerValueHighLimit.go | 10 ++++++++++
.../BACnetConstructedDataPositiveIntegerValueLowLimit.go | 10 ++++++++++
...ACnetConstructedDataPositiveIntegerValueMaxPresValue.go | 10 ++++++++++
...ACnetConstructedDataPositiveIntegerValueMinPresValue.go | 10 ++++++++++
...ConstructedDataPositiveIntegerValueRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataPositiveIntegerValueResolution.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataPower.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPowerMode.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPrescale.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPriority.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPriorityArray.go | 10 ++++++++++
.../model/BACnetConstructedDataPriorityForWriting.go | 10 ++++++++++
.../model/BACnetConstructedDataProcessIdentifier.go | 10 ++++++++++
.../model/BACnetConstructedDataProcessIdentifierFilter.go | 10 ++++++++++
.../model/BACnetConstructedDataProfileLocation.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataProfileName.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataProgramAll.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataProgramChange.go | 10 ++++++++++
.../model/BACnetConstructedDataProgramLocation.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataProgramState.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPropertyList.go | 10 ++++++++++
.../model/BACnetConstructedDataProportionalConstant.go | 10 ++++++++++
.../BACnetConstructedDataProportionalConstantUnits.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataProtocolLevel.go | 10 ++++++++++
.../BACnetConstructedDataProtocolObjectTypesSupported.go | 10 ++++++++++
.../model/BACnetConstructedDataProtocolRevision.go | 10 ++++++++++
.../BACnetConstructedDataProtocolServicesSupported.go | 10 ++++++++++
.../model/BACnetConstructedDataProtocolVersion.go | 10 ++++++++++
.../BACnetConstructedDataPulseConverterAdjustValue.go | 10 ++++++++++
.../model/BACnetConstructedDataPulseConverterAll.go | 10 ++++++++++
.../BACnetConstructedDataPulseConverterPresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataPulseRate.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataReadOnly.go | 10 ++++++++++
.../model/BACnetConstructedDataReasonForDisable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataReasonForHalt.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataRecipientList.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataRecordCount.go | 10 ++++++++++
.../model/BACnetConstructedDataRecordsSinceNotification.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataReferencePort.go | 10 ++++++++++
.../model/BACnetConstructedDataRegisteredCarCall.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataReliability.go | 10 ++++++++++
.../BACnetConstructedDataReliabilityEvaluationInhibit.go | 10 ++++++++++
.../model/BACnetConstructedDataRelinquishDefault.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataRepresents.go | 10 ++++++++++
.../model/BACnetConstructedDataRequestedShedLevel.go | 10 ++++++++++
.../model/BACnetConstructedDataRequestedUpdateInterval.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataRequired.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataResolution.go | 10 ++++++++++
.../BACnetConstructedDataRestartNotificationRecipients.go | 10 ++++++++++
.../model/BACnetConstructedDataRestoreCompletionTime.go | 10 ++++++++++
.../model/BACnetConstructedDataRestorePreparationTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataRoutingTable.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataScale.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataScaleFactor.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataScheduleAll.go | 10 ++++++++++
.../model/BACnetConstructedDataScheduleDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataSchedulePresentValue.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSecuredStatus.go | 10 ++++++++++
.../model/BACnetConstructedDataSecurityPDUTimeout.go | 10 ++++++++++
.../model/BACnetConstructedDataSecurityTimeWindow.go | 10 ++++++++++
.../model/BACnetConstructedDataSegmentationSupported.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSerialNumber.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSetpoint.go | 10 ++++++++++
.../model/BACnetConstructedDataSetpointReference.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSetting.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataShedDuration.go | 10 ++++++++++
.../model/BACnetConstructedDataShedLevelDescriptions.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataShedLevels.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSilenced.go | 10 ++++++++++
.../model/BACnetConstructedDataSlaveAddressBinding.go | 10 ++++++++++
.../model/BACnetConstructedDataSlaveProxyEnable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStartTime.go | 10 ++++++++++
.../model/BACnetConstructedDataStateChangeValues.go | 10 ++++++++++
.../model/BACnetConstructedDataStateDescription.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStateText.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStatusFlags.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStopTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStopWhenFull.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataStrikeCount.go | 10 ++++++++++
.../model/BACnetConstructedDataStructuredObjectList.go | 10 ++++++++++
.../model/BACnetConstructedDataStructuredViewAll.go | 10 ++++++++++
.../model/BACnetConstructedDataSubordinateAnnotations.go | 10 ++++++++++
.../model/BACnetConstructedDataSubordinateList.go | 10 ++++++++++
.../model/BACnetConstructedDataSubordinateNodeTypes.go | 10 ++++++++++
.../model/BACnetConstructedDataSubordinateRelationships.go | 10 ++++++++++
.../model/BACnetConstructedDataSubordinateTags.go | 10 ++++++++++
.../model/BACnetConstructedDataSubscribedRecipients.go | 10 ++++++++++
.../model/BACnetConstructedDataSupportedFormatClasses.go | 10 ++++++++++
.../model/BACnetConstructedDataSupportedFormats.go | 10 ++++++++++
.../BACnetConstructedDataSupportedSecurityAlgorithms.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataSystemStatus.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataTags.go | 10 ++++++++++
.../model/BACnetConstructedDataThreatAuthority.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataThreatLevel.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTimeDelay.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeDelayNormal.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeOfActiveTimeReset.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeOfDeviceRestart.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeOfStateCountReset.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeOfStrikeCountReset.go | 10 ++++++++++
.../BACnetConstructedDataTimePatternValuePresentValue.go | 10 ++++++++++
...CnetConstructedDataTimePatternValueRelinquishDefault.go | 10 ++++++++++
.../BACnetConstructedDataTimeSynchronizationInterval.go | 10 ++++++++++
.../BACnetConstructedDataTimeSynchronizationRecipients.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTimeValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataTimeValuePresentValue.go | 10 ++++++++++
.../BACnetConstructedDataTimeValueRelinquishDefault.go | 10 ++++++++++
.../model/BACnetConstructedDataTimepatternValueAll.go | 10 ++++++++++
.../model/BACnetConstructedDataTimerAlarmValues.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTimerAll.go | 10 ++++++++++
.../model/BACnetConstructedDataTimerMaxPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataTimerMinPresValue.go | 10 ++++++++++
.../model/BACnetConstructedDataTimerResolution.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTimerRunning.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTimerState.go | 10 ++++++++++
.../model/BACnetConstructedDataTotalRecordCount.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTraceFlag.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTrackingValue.go | 10 ++++++++++
.../BACnetConstructedDataTransactionNotificationClass.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTransition.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTrendLogAll.go | 10 ++++++++++
.../model/BACnetConstructedDataTrendLogLogBuffer.go | 10 ++++++++++
...BACnetConstructedDataTrendLogLogDeviceObjectProperty.go | 10 ++++++++++
.../model/BACnetConstructedDataTrendLogMultipleAll.go | 10 ++++++++++
.../BACnetConstructedDataTrendLogMultipleLogBuffer.go | 10 ++++++++++
...nstructedDataTrendLogMultipleLogDeviceObjectProperty.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataTrigger.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUTCOffset.go | 10 ++++++++++
...ACnetConstructedDataUTCTimeSynchronizationRecipients.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetConstructedDataUnits.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUnspecified.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUpdateInterval.go | 10 ++++++++++
.../model/BACnetConstructedDataUpdateKeySetTimeout.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUpdateTime.go | 10 ++++++++++
.../model/BACnetConstructedDataUserExternalIdentifier.go | 10 ++++++++++
.../model/BACnetConstructedDataUserInformationReference.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUserName.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUserType.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataUsesRemaining.go | 10 ++++++++++
.../model/BACnetConstructedDataVTClassesSupported.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataValidSamples.go | 10 ++++++++++
.../model/BACnetConstructedDataValueBeforeChange.go | 10 ++++++++++
.../model/BACnetConstructedDataValueChangeTime.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataValueSet.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataValueSource.go | 10 ++++++++++
.../model/BACnetConstructedDataValueSourceArray.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataVarianceValue.go | 10 ++++++++++
.../model/BACnetConstructedDataVendorIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataVendorName.go | 10 ++++++++++
.../model/BACnetConstructedDataVerificationTime.go | 10 ++++++++++
.../model/BACnetConstructedDataVirtualMACAddressTable.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataWeeklySchedule.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataWindowInterval.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataWindowSamples.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataWriteStatus.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataZoneFrom.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataZoneMembers.go | 10 ++++++++++
.../readwrite/model/BACnetConstructedDataZoneTo.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetContextTag.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetContextTagBitString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetContextTagCharacterString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagDate.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagDouble.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagEnumerated.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagNull.go | 10 ++++++++++
.../readwrite/model/BACnetContextTagObjectIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetContextTagOctetString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagReal.go | 10 ++++++++++
.../readwrite/model/BACnetContextTagSignedInteger.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetContextTagUnknown.go | 10 ++++++++++
.../readwrite/model/BACnetContextTagUnsignedInteger.go | 10 ++++++++++
.../model/BACnetCredentialAuthenticationFactor.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDailySchedule.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetDateRange.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDateRangeEnclosed.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetDateTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDateTimeEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDaysOfWeekTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDestination.go | 10 ++++++++++
.../readwrite/model/BACnetDeviceObjectPropertyReference.go | 10 ++++++++++
.../model/BACnetDeviceObjectPropertyReferenceEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetDeviceObjectReference.go | 10 ++++++++++
.../readwrite/model/BACnetDeviceObjectReferenceEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDeviceStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDoorAlarmStateTagged.go | 10 ++++++++++
.../readwrite/model/BACnetDoorSecuredStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDoorStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetDoorValueTagged.go | 10 ++++++++++
.../readwrite/model/BACnetEngineeringUnitsTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BACnetError.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetErrorGeneral.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEscalatorFaultTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEscalatorModeTagged.go | 10 ++++++++++
.../model/BACnetEscalatorOperationDirectionTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventLogRecord.go | 10 ++++++++++
.../readwrite/model/BACnetEventLogRecordLogDatum.go | 14 ++++++++++++--
.../model/BACnetEventLogRecordLogDatumLogStatus.go | 10 ++++++++++
.../model/BACnetEventLogRecordLogDatumNotification.go | 10 ++++++++++
.../model/BACnetEventLogRecordLogDatumTimeChange.go | 10 ++++++++++
.../readwrite/model/BACnetEventNotificationSubscription.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventParameter.go | 14 ++++++++++++--
.../readwrite/model/BACnetEventParameterAccessEvent.go | 10 ++++++++++
.../BACnetEventParameterAccessEventListOfAccessEvents.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterBufferReady.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfBitstring.go | 10 ++++++++++
...EventParameterChangeOfBitstringListOfBitstringValues.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfCharacterString.go | 10 ++++++++++
...entParameterChangeOfCharacterStringListOfAlarmValues.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfDiscreteValue.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfLifeSavety.go | 10 ++++++++++
...netEventParameterChangeOfLifeSavetyListOfAlarmValues.go | 10 ++++++++++
...rameterChangeOfLifeSavetyListOfLifeSavetyAlarmValues.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterChangeOfState.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfStateListOfValues.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfStatusFlags.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterChangeOfTimer.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfTimerAlarmValue.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterChangeOfValue.go | 10 ++++++++++
.../model/BACnetEventParameterChangeOfValueCivCriteria.go | 14 ++++++++++++--
.../BACnetEventParameterChangeOfValueCivCriteriaBitmask.go | 10 ++++++++++
...rChangeOfValueCivCriteriaReferencedPropertyIncrement.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterCommandFailure.go | 10 ++++++++++
.../model/BACnetEventParameterDoubleOutOfRange.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterExtended.go | 10 ++++++++++
.../model/BACnetEventParameterExtendedParameters.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterFloatingLimit.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventParameterNone.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterOutOfRange.go | 10 ++++++++++
.../model/BACnetEventParameterSignedOutOfRange.go | 10 ++++++++++
.../model/BACnetEventParameterUnsignedOutOfRange.go | 10 ++++++++++
.../readwrite/model/BACnetEventParameterUnsignedRange.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventPriorities.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventSummariesList.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventSummary.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventTimestamps.go | 10 ++++++++++
.../readwrite/model/BACnetEventTimestampsEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetEventTransitionBitsTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetEventTypeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetFaultParameter.go | 14 ++++++++++++--
.../model/BACnetFaultParameterFaultCharacterString.go | 10 ++++++++++
...tFaultParameterFaultCharacterStringListOfFaultValues.go | 10 ++++++++++
.../readwrite/model/BACnetFaultParameterFaultExtended.go | 10 ++++++++++
.../model/BACnetFaultParameterFaultExtendedParameters.go | 10 ++++++++++
.../BACnetFaultParameterFaultExtendedParametersEntry.go | 14 ++++++++++++--
...tFaultParameterFaultExtendedParametersEntryBitString.go | 10 ++++++++++
...netFaultParameterFaultExtendedParametersEntryBoolean.go | 10 ++++++++++
...ParameterFaultExtendedParametersEntryCharacterString.go | 10 ++++++++++
...BACnetFaultParameterFaultExtendedParametersEntryDate.go | 10 ++++++++++
...CnetFaultParameterFaultExtendedParametersEntryDouble.go | 10 ++++++++++
...FaultParameterFaultExtendedParametersEntryEnumerated.go | 10 ++++++++++
...netFaultParameterFaultExtendedParametersEntryInteger.go | 10 ++++++++++
...BACnetFaultParameterFaultExtendedParametersEntryNull.go | 10 ++++++++++
...arameterFaultExtendedParametersEntryObjectidentifier.go | 10 ++++++++++
...aultParameterFaultExtendedParametersEntryOctetString.go | 10 ++++++++++
...BACnetFaultParameterFaultExtendedParametersEntryReal.go | 10 ++++++++++
...tFaultParameterFaultExtendedParametersEntryReference.go | 10 ++++++++++
...BACnetFaultParameterFaultExtendedParametersEntryTime.go | 10 ++++++++++
...etFaultParameterFaultExtendedParametersEntryUnsigned.go | 10 ++++++++++
.../readwrite/model/BACnetFaultParameterFaultLifeSafety.go | 10 ++++++++++
...BACnetFaultParameterFaultLifeSafetyListOfFaultValues.go | 10 ++++++++++
.../readwrite/model/BACnetFaultParameterFaultListed.go | 10 ++++++++++
.../readwrite/model/BACnetFaultParameterFaultOutOfRange.go | 10 ++++++++++
.../BACnetFaultParameterFaultOutOfRangeMaxNormalValue.go | 14 ++++++++++++--
...netFaultParameterFaultOutOfRangeMaxNormalValueDouble.go | 10 ++++++++++
...etFaultParameterFaultOutOfRangeMaxNormalValueInteger.go | 10 ++++++++++
...ACnetFaultParameterFaultOutOfRangeMaxNormalValueReal.go | 10 ++++++++++
...tFaultParameterFaultOutOfRangeMaxNormalValueUnsigned.go | 10 ++++++++++
.../BACnetFaultParameterFaultOutOfRangeMinNormalValue.go | 14 ++++++++++++--
...netFaultParameterFaultOutOfRangeMinNormalValueDouble.go | 10 ++++++++++
...etFaultParameterFaultOutOfRangeMinNormalValueInteger.go | 10 ++++++++++
...ACnetFaultParameterFaultOutOfRangeMinNormalValueReal.go | 10 ++++++++++
...tFaultParameterFaultOutOfRangeMinNormalValueUnsigned.go | 10 ++++++++++
.../readwrite/model/BACnetFaultParameterFaultState.go | 10 ++++++++++
.../BACnetFaultParameterFaultStateListOfFaultValues.go | 10 ++++++++++
.../model/BACnetFaultParameterFaultStatusFlags.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetFaultParameterNone.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetFaultTypeTagged.go | 10 ++++++++++
.../readwrite/model/BACnetFileAccessMethodTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetGroupChannelValue.go | 10 ++++++++++
.../readwrite/model/BACnetGroupChannelValueList.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetHostAddress.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetHostAddressEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetHostAddressIpAddress.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetHostAddressName.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetHostAddressNull.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetHostNPort.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetHostNPortEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetIPModeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetKeyIdentifier.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLandingCallStatus.go | 10 ++++++++++
.../readwrite/model/BACnetLandingCallStatusCommand.go | 14 ++++++++++++--
.../model/BACnetLandingCallStatusCommandDestination.go | 10 ++++++++++
.../model/BACnetLandingCallStatusCommandDirection.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLandingDoorStatus.go | 10 ++++++++++
.../model/BACnetLandingDoorStatusLandingDoorsList.go | 10 ++++++++++
.../model/BACnetLandingDoorStatusLandingDoorsListEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLifeSafetyModeTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLifeSafetyOperationTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLifeSafetyStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLiftCarCallList.go | 10 ++++++++++
.../readwrite/model/BACnetLiftCarCallListFloorList.go | 10 ++++++++++
.../readwrite/model/BACnetLiftCarDirectionTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLiftCarDoorCommandTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLiftCarDriveStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLiftCarModeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLiftFaultTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLiftGroupModeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLightingCommand.go | 10 ++++++++++
.../readwrite/model/BACnetLightingCommandEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetLightingInProgressTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLightingOperationTagged.go | 10 ++++++++++
.../readwrite/model/BACnetLightingTransitionTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLimitEnableTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLockStatusTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BACnetLogData.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetLogDataLogData.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLogDataLogDataEntry.go | 14 ++++++++++++--
.../readwrite/model/BACnetLogDataLogDataEntryAnyValue.go | 10 ++++++++++
.../model/BACnetLogDataLogDataEntryBitStringValue.go | 10 ++++++++++
.../model/BACnetLogDataLogDataEntryBooleanValue.go | 10 ++++++++++
.../model/BACnetLogDataLogDataEntryEnumeratedValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogDataLogDataEntryFailure.go | 10 ++++++++++
.../model/BACnetLogDataLogDataEntryIntegerValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogDataLogDataEntryNullValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogDataLogDataEntryRealValue.go | 10 ++++++++++
.../model/BACnetLogDataLogDataEntryUnsignedValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogDataLogDataTimeChange.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLogDataLogStatus.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLogMultipleRecord.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetLogRecord.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLogRecordLogDatum.go | 14 ++++++++++++--
.../readwrite/model/BACnetLogRecordLogDatumAnyValue.go | 10 ++++++++++
.../model/BACnetLogRecordLogDatumBitStringValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumBooleanValue.go | 10 ++++++++++
.../model/BACnetLogRecordLogDatumEnumeratedValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumFailure.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumIntegerValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumLogStatus.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumNullValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumRealValue.go | 10 ++++++++++
.../readwrite/model/BACnetLogRecordLogDatumTimeChange.go | 10 ++++++++++
.../model/BACnetLogRecordLogDatumUnsignedValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLogStatusTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetLoggingTypeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetMaintenanceTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetNameValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetNameValueCollection.go | 10 ++++++++++
.../readwrite/model/BACnetNetworkNumberQualityTagged.go | 10 ++++++++++
.../readwrite/model/BACnetNetworkPortCommandTagged.go | 10 ++++++++++
.../readwrite/model/BACnetNetworkSecurityPolicy.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetNetworkTypeTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetNodeTypeTagged.go | 10 ++++++++++
.../readwrite/model/BACnetNotificationParameters.go | 14 ++++++++++++--
.../model/BACnetNotificationParametersAccessEvent.go | 10 ++++++++++
.../model/BACnetNotificationParametersBufferReady.go | 10 ++++++++++
.../model/BACnetNotificationParametersChangeOfBitString.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfCharacterString.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfDiscreteValue.go | 10 ++++++++++
...tNotificationParametersChangeOfDiscreteValueNewValue.go | 14 ++++++++++++--
...cationParametersChangeOfDiscreteValueNewValueBoolean.go | 10 ++++++++++
...rametersChangeOfDiscreteValueNewValueCharacterString.go | 10 ++++++++++
...ationParametersChangeOfDiscreteValueNewValueDatetime.go | 10 ++++++++++
...ionParametersChangeOfDiscreteValueNewValueEnumerated.go | 10 ++++++++++
...cationParametersChangeOfDiscreteValueNewValueInteger.go | 10 ++++++++++
...ametersChangeOfDiscreteValueNewValueObjectidentifier.go | 10 ++++++++++
...tionParametersChangeOfDiscreteValueNewValueOctetDate.go | 10 ++++++++++
...onParametersChangeOfDiscreteValueNewValueOctetString.go | 10 ++++++++++
...tionParametersChangeOfDiscreteValueNewValueOctetTime.go | 10 ++++++++++
...ationParametersChangeOfDiscreteValueNewValueUnsigned.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfLifeSafety.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfReliability.go | 10 ++++++++++
.../model/BACnetNotificationParametersChangeOfState.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfStatusFlags.go | 10 ++++++++++
.../model/BACnetNotificationParametersChangeOfTimer.go | 10 ++++++++++
.../model/BACnetNotificationParametersChangeOfValue.go | 10 ++++++++++
.../BACnetNotificationParametersChangeOfValueNewValue.go | 14 ++++++++++++--
...tificationParametersChangeOfValueNewValueChangedBits.go | 10 ++++++++++
...ificationParametersChangeOfValueNewValueChangedValue.go | 10 ++++++++++
.../model/BACnetNotificationParametersCommandFailure.go | 10 ++++++++++
.../model/BACnetNotificationParametersComplexEventType.go | 10 ++++++++++
.../model/BACnetNotificationParametersDoubleOutOfRange.go | 10 ++++++++++
.../model/BACnetNotificationParametersExtended.go | 10 ++++++++++
.../BACnetNotificationParametersExtendedParameters.go | 10 ++++++++++
.../model/BACnetNotificationParametersFloatingLimit.go | 10 ++++++++++
.../model/BACnetNotificationParametersOutOfRange.go | 10 ++++++++++
.../model/BACnetNotificationParametersSignedOutOfRange.go | 10 ++++++++++
.../BACnetNotificationParametersUnsignedOutOfRange.go | 10 ++++++++++
.../model/BACnetNotificationParametersUnsignedRange.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetNotifyTypeTagged.go | 10 ++++++++++
.../readwrite/model/BACnetObjectPropertyReference.go | 10 ++++++++++
.../model/BACnetObjectPropertyReferenceEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetObjectTypeTagged.go | 10 ++++++++++
.../readwrite/model/BACnetObjectTypesSupportedTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetOpeningTag.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetOptionalBinaryPV.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetOptionalBinaryPVNull.go | 10 ++++++++++
.../readwrite/model/BACnetOptionalBinaryPVValue.go | 10 ++++++++++
.../readwrite/model/BACnetOptionalCharacterString.go | 14 ++++++++++++--
.../readwrite/model/BACnetOptionalCharacterStringNull.go | 10 ++++++++++
.../readwrite/model/BACnetOptionalCharacterStringValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetOptionalREAL.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetOptionalREALNull.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetOptionalREALValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetOptionalUnsigned.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetOptionalUnsignedNull.go | 10 ++++++++++
.../readwrite/model/BACnetOptionalUnsignedValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPolarityTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPortPermission.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetPrescale.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityArray.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValue.go | 14 ++++++++++++--
.../readwrite/model/BACnetPriorityValueBitString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueCharacterString.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueConstructedValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueDate.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueDateTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueDouble.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueEnumerated.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueInteger.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueNull.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueObjectidentifier.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueOctetString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueReal.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPriorityValueTime.go | 10 ++++++++++
.../readwrite/model/BACnetPriorityValueUnsigned.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetProcessIdSelection.go | 14 ++++++++++++--
.../readwrite/model/BACnetProcessIdSelectionNull.go | 10 ++++++++++
.../readwrite/model/BACnetProcessIdSelectionValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetProgramErrorTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetProgramRequestTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetProgramStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyAccessResult.go | 10 ++++++++++
.../model/BACnetPropertyAccessResultAccessResult.go | 14 ++++++++++++--
...tPropertyAccessResultAccessResultPropertyAccessError.go | 10 ++++++++++
.../BACnetPropertyAccessResultAccessResultPropertyValue.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyIdentifierTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyReference.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyReferenceEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStateActionUnknown.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyStates.go | 14 ++++++++++++--
.../model/BACnetPropertyStatesAccessCredentialDisable.go | 10 ++++++++++
.../BACnetPropertyStatesAccessCredentialDisableReason.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesAccessEvent.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyStatesAction.go | 10 ++++++++++
.../model/BACnetPropertyStatesAuthenticationStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesBackupState.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesBacnetIpMode.go | 10 ++++++++++
.../model/BACnetPropertyStatesBinaryLightningValue.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesBinaryValue.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesDoorAlarmState.go | 10 ++++++++++
.../model/BACnetPropertyStatesDoorSecuredStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesDoorStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesDoorValue.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesEnclosed.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesEscalatorFault.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesEscalatorMode.go | 10 ++++++++++
.../BACnetPropertyStatesEscalatorOperationDirection.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesEventType.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesExtendedValue.go | 10 ++++++++++
.../model/BACnetPropertyStatesFileAccessMethod.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesIntegerValue.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLifeSafetyMode.go | 10 ++++++++++
.../model/BACnetPropertyStatesLifeSafetyOperations.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLifeSafetyState.go | 10 ++++++++++
.../model/BACnetPropertyStatesLiftCarDirection.go | 10 ++++++++++
.../model/BACnetPropertyStatesLiftCarDoorCommand.go | 10 ++++++++++
.../model/BACnetPropertyStatesLiftCarDriveStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLiftCarMode.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLiftFault.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLiftGroupMode.go | 10 ++++++++++
.../model/BACnetPropertyStatesLightningInProgress.go | 10 ++++++++++
.../model/BACnetPropertyStatesLightningOperation.go | 10 ++++++++++
.../model/BACnetPropertyStatesLightningTransition.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesLockStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesMaintenance.go | 10 ++++++++++
.../model/BACnetPropertyStatesNetworkNumberQuality.go | 10 ++++++++++
.../model/BACnetPropertyStatesNetworkPortCommand.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesNetworkType.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesNodeType.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesNotifyType.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesPolarity.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesProgramChange.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesProtocolLevel.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesReasonForHalt.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesReliability.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesRestartReason.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesSecurityLevel.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesShedState.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesSilencedState.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyStatesState.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesSystemStatus.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesTimerState.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesTimerTransition.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyStatesUnits.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyStatesWriteStatus.go | 10 ++++++++++
.../model/BACnetPropertyStatesZoneOccupanyState.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyValue.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetPropertyValues.go | 10 ++++++++++
.../readwrite/model/BACnetPropertyWriteDefinition.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetProtocolLevelTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetReadAccessProperty.go | 10 ++++++++++
.../readwrite/model/BACnetReadAccessPropertyReadResult.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetReadAccessResult.go | 10 ++++++++++
.../readwrite/model/BACnetReadAccessResultListOfResults.go | 10 ++++++++++
.../readwrite/model/BACnetReadAccessSpecification.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetRecipient.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetRecipientAddress.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRecipientDevice.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRecipientEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRecipientProcess.go | 10 ++++++++++
.../readwrite/model/BACnetRecipientProcessEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRejectReasonTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRelationshipTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetReliabilityTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRestartReasonTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetResultFlagsTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetRouterEntry.go | 10 ++++++++++
.../readwrite/model/BACnetRouterEntryStatusTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BACnetScale.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetScaleFloatScale.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetScaleIntegerScale.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSecurityKeySet.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSecurityKeySetKeyIds.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSecurityLevelTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSecurityPolicyTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSegmentationTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetServiceAck.go | 14 ++++++++++++--
.../readwrite/model/BACnetServiceAckAtomicReadFile.go | 10 ++++++++++
.../model/BACnetServiceAckAtomicReadFileRecord.go | 10 ++++++++++
.../model/BACnetServiceAckAtomicReadFileStream.go | 10 ++++++++++
.../model/BACnetServiceAckAtomicReadFileStreamOrRecord.go | 14 ++++++++++++--
.../readwrite/model/BACnetServiceAckAtomicWriteFile.go | 10 ++++++++++
.../readwrite/model/BACnetServiceAckAuthenticate.go | 10 ++++++++++
.../model/BACnetServiceAckConfirmedPrivateTransfer.go | 10 ++++++++++
.../readwrite/model/BACnetServiceAckCreateObject.go | 10 ++++++++++
.../readwrite/model/BACnetServiceAckGetAlarmSummary.go | 10 ++++++++++
.../model/BACnetServiceAckGetEnrollmentSummary.go | 10 ++++++++++
.../readwrite/model/BACnetServiceAckGetEventInformation.go | 10 ++++++++++
.../readwrite/model/BACnetServiceAckReadProperty.go | 10 ++++++++++
.../model/BACnetServiceAckReadPropertyConditional.go | 10 ++++++++++
.../model/BACnetServiceAckReadPropertyMultiple.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetServiceAckReadRange.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetServiceAckRequestKey.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetServiceAckVTData.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetServiceAckVTOpen.go | 10 ++++++++++
.../readwrite/model/BACnetServicesSupportedTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSetpointReference.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetShedLevel.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetShedLevelAmount.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetShedLevelLevel.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetShedLevelPercent.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetShedStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSilencedStateTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSpecialEvent.go | 10 ++++++++++
.../readwrite/model/BACnetSpecialEventListOfTimeValues.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetSpecialEventPeriod.go | 14 ++++++++++++--
.../model/BACnetSpecialEventPeriodCalendarEntry.go | 10 ++++++++++
.../model/BACnetSpecialEventPeriodCalendarReference.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetStatusFlagsTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetTagHeader.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadBitString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadBoolean.go | 10 ++++++++++
.../readwrite/model/BACnetTagPayloadCharacterString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadDate.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadDouble.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadEnumerated.go | 10 ++++++++++
.../readwrite/model/BACnetTagPayloadObjectIdentifier.go | 10 ++++++++++
.../readwrite/model/BACnetTagPayloadOctetString.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadReal.go | 10 ++++++++++
.../readwrite/model/BACnetTagPayloadSignedInteger.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTagPayloadTime.go | 10 ++++++++++
.../readwrite/model/BACnetTagPayloadUnsignedInteger.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetTimeStamp.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetTimeStampDateTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTimeStampEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTimeStampSequence.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTimeStampTime.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTimeStampsEnclosed.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetTimeValue.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValue.go | 14 ++++++++++++--
.../model/BACnetTimerStateChangeValueBitString.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueBoolean.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueCharacterString.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueConstructedValue.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueDate.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueDateTime.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueDouble.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueEnumerated.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueInteger.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueLightingCommand.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueNoValue.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueNull.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueObjectidentifier.go | 10 ++++++++++
.../model/BACnetTimerStateChangeValueOctetString.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueReal.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueTime.go | 10 ++++++++++
.../readwrite/model/BACnetTimerStateChangeValueUnsigned.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetTimerStateTagged.go | 10 ++++++++++
.../readwrite/model/BACnetTimerTransitionTagged.go | 10 ++++++++++
.../model/BACnetUnconfirmedServiceChoiceTagged.go | 10 ++++++++++
.../readwrite/model/BACnetUnconfirmedServiceRequest.go | 14 ++++++++++++--
.../readwrite/model/BACnetUnconfirmedServiceRequestIAm.go | 10 ++++++++++
.../model/BACnetUnconfirmedServiceRequestIHave.go | 10 ++++++++++
.../BACnetUnconfirmedServiceRequestTimeSynchronization.go | 10 ++++++++++
...ACnetUnconfirmedServiceRequestUTCTimeSynchronization.go | 10 ++++++++++
...tUnconfirmedServiceRequestUnconfirmedCOVNotification.go | 10 ++++++++++
...rmedServiceRequestUnconfirmedCOVNotificationMultiple.go | 10 ++++++++++
...nconfirmedServiceRequestUnconfirmedEventNotification.go | 10 ++++++++++
...tUnconfirmedServiceRequestUnconfirmedPrivateTransfer.go | 10 ++++++++++
...ACnetUnconfirmedServiceRequestUnconfirmedTextMessage.go | 10 ++++++++++
.../BACnetUnconfirmedServiceRequestUnconfirmedUnknown.go | 10 ++++++++++
.../model/BACnetUnconfirmedServiceRequestWhoHas.go | 10 ++++++++++
.../model/BACnetUnconfirmedServiceRequestWhoIs.go | 10 ++++++++++
.../model/BACnetUnconfirmedServiceRequestWriteGroup.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetVMACEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetVTClassTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetVTSession.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetValueSource.go | 14 ++++++++++++--
.../bacnetip/readwrite/model/BACnetValueSourceAddress.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetValueSourceNone.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetValueSourceObject.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetVendorIdTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BACnetWeekNDay.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetWeekNDayTagged.go | 10 ++++++++++
.../readwrite/model/BACnetWriteAccessSpecification.go | 10 ++++++++++
.../bacnetip/readwrite/model/BACnetWriteStatusTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BVLC.go | 14 ++++++++++++--
.../readwrite/model/BVLCBroadcastDistributionTableEntry.go | 10 ++++++++++
.../readwrite/model/BVLCDeleteForeignDeviceTableEntry.go | 10 ++++++++++
.../readwrite/model/BVLCDistributeBroadcastToNetwork.go | 10 ++++++++++
.../readwrite/model/BVLCForeignDeviceTableEntry.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCForwardedNPDU.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCOriginalBroadcastNPDU.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCOriginalUnicastNPDU.go | 10 ++++++++++
.../readwrite/model/BVLCReadBroadcastDistributionTable.go | 10 ++++++++++
.../model/BVLCReadBroadcastDistributionTableAck.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCReadForeignDeviceTable.go | 10 ++++++++++
.../readwrite/model/BVLCReadForeignDeviceTableAck.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCRegisterForeignDevice.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/BVLCResult.go | 10 ++++++++++
.../bacnetip/readwrite/model/BVLCResultCodeTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/BVLCSecureBVLL.go | 10 ++++++++++
.../readwrite/model/BVLCWriteBroadcastDistributionTable.go | 10 ++++++++++
.../bacnetip/readwrite/model/ChangeListAddError.go | 10 ++++++++++
.../bacnetip/readwrite/model/ChangeListRemoveError.go | 10 ++++++++++
.../readwrite/model/ConfirmedEventNotificationRequest.go | 10 ++++++++++
.../readwrite/model/ConfirmedPrivateTransferError.go | 10 ++++++++++
.../bacnetip/readwrite/model/CreateObjectError.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/Error.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/ErrorClassTagged.go | 10 ++++++++++
.../protocols/bacnetip/readwrite/model/ErrorCodeTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/ErrorEnclosed.go | 10 ++++++++++
.../bacnetip/readwrite/model/ListOfCovNotifications.go | 10 ++++++++++
.../bacnetip/readwrite/model/ListOfCovNotificationsList.go | 10 ++++++++++
.../readwrite/model/ListOfCovNotificationsValue.go | 10 ++++++++++
.../readwrite/model/MaxApduLengthAcceptedTagged.go | 10 ++++++++++
.../bacnetip/readwrite/model/MaxSegmentsAcceptedTagged.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/NLM.go | 14 ++++++++++++--
.../readwrite/model/NLMDisconnectConnectionToNetwork.go | 10 ++++++++++
.../readwrite/model/NLMEstablishConnectionToNetwork.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMIAmRouterToNetwork.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMICouldBeRouterToNetwork.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMInitalizeRoutingTable.go | 10 ++++++++++
.../readwrite/model/NLMInitalizeRoutingTableAck.go | 10 ++++++++++
.../readwrite/model/NLMInitalizeRoutingTablePortMapping.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMRejectRouterToNetwork.go | 10 ++++++++++
.../readwrite/model/NLMRouterAvailableToNetwork.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMRouterBusyToNetwork.go | 10 ++++++++++
.../bacnetip/readwrite/model/NLMWhoIsRouterToNetwork.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/NPDU.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/NPDUControl.go | 10 ++++++++++
.../bacnetip/readwrite/model/NPDUNetworkPriorityTagged.go | 10 ++++++++++
.../readwrite/model/SubscribeCOVPropertyMultipleError.go | 10 ++++++++++
...cribeCOVPropertyMultipleErrorFirstFailedSubscription.go | 10 ++++++++++
plc4go/protocols/bacnetip/readwrite/model/VTCloseError.go | 10 ++++++++++
.../model/VTCloseErrorListOfVTSessionIdentifiers.go | 10 ++++++++++
.../bacnetip/readwrite/model/WritePropertyMultipleError.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/Alpha.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/BridgeAddress.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/BridgeCount.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CALData.go | 14 ++++++++++++--
.../cbus/readwrite/model/CALDataReplyAcknowledge.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CALDataReplyReply.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/CALDataReplyStatus.go | 10 ++++++++++
.../cbus/readwrite/model/CALDataReplyStatusExtended.go | 10 ++++++++++
.../cbus/readwrite/model/CALDataRequestGetStatus.go | 10 ++++++++++
.../cbus/readwrite/model/CALDataRequestIdentify.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/CALDataRequestRecall.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/CALDataRequestReset.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CALReply.go | 14 ++++++++++++--
plc4go/protocols/cbus/readwrite/model/CALReplyLong.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CALReplyReply.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CALReplyShort.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CBusCommand.go | 14 ++++++++++++--
.../cbus/readwrite/model/CBusCommandPointToMultiPoint.go | 10 ++++++++++
.../cbus/readwrite/model/CBusCommandPointToPoint.go | 10 ++++++++++
.../readwrite/model/CBusCommandPointToPointToMultiPoint.go | 10 ++++++++++
.../model/CBusCommandPointToPointToMultiPointNormal.go | 10 ++++++++++
.../model/CBusCommandPointToPointToMultiPointStatus.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CBusHeader.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CBusOptions.go | 10 ++++++++++
.../cbus/readwrite/model/CBusPointToMultiPointCommand.go | 14 ++++++++++++--
.../readwrite/model/CBusPointToMultiPointCommandNormal.go | 10 ++++++++++
.../readwrite/model/CBusPointToMultiPointCommandStatus.go | 10 ++++++++++
.../cbus/readwrite/model/CBusPointToPointCommand.go | 14 ++++++++++++--
.../cbus/readwrite/model/CBusPointToPointCommandDirect.go | 10 ++++++++++
.../readwrite/model/CBusPointToPointCommandIndirect.go | 10 ++++++++++
.../readwrite/model/CBusPointToPointToMultipointCommand.go | 14 ++++++++++++--
plc4go/protocols/cbus/readwrite/model/Checksum.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/CommandHeader.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/Confirmation.go | 14 ++++++++++++--
plc4go/protocols/cbus/readwrite/model/ConfirmationReply.go | 10 ++++++++++
.../cbus/readwrite/model/ConfirmationSuccessful.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/ExclamationMark.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/ExclamationMarkReply.go | 10 ++++++++++
.../cbus/readwrite/model/ExtendedFormatStatusReply.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/ExtendedStatusHeader.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/IdentifyReplyCommand.go | 14 ++++++++++++--
.../model/IdentifyReplyCommandCurrentSenseLevels.go | 10 ++++++++++
.../cbus/readwrite/model/IdentifyReplyCommandDSIStatus.go | 10 ++++++++++
.../cbus/readwrite/model/IdentifyReplyCommandDelays.go | 10 ++++++++++
.../model/IdentifyReplyCommandExtendedDiagnosticSummary.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandFirmwareSummary.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandFirmwareVersion.go | 10 ++++++++++
.../model/IdentifyReplyCommandGAVPhysicalAddresses.go | 10 ++++++++++
.../model/IdentifyReplyCommandGAVValuesCurrent.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandGAVValuesStored.go | 10 ++++++++++
.../model/IdentifyReplyCommandLogicalAssignment.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandManufacturer.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandMaximumLevels.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandMinimumLevels.go | 10 ++++++++++
.../model/IdentifyReplyCommandNetworkTerminalLevels.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandNetworkVoltage.go | 10 ++++++++++
.../model/IdentifyReplyCommandOutputUnitSummary.go | 10 ++++++++++
.../readwrite/model/IdentifyReplyCommandTerminalLevels.go | 10 ++++++++++
.../cbus/readwrite/model/IdentifyReplyCommandType.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/MonitoredSAL.go | 14 ++++++++++++--
.../cbus/readwrite/model/MonitoredSALLongFormSmartMode.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/MonitoredSALReply.go | 10 ++++++++++
.../cbus/readwrite/model/MonitoredSALShortFormBasicMode.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/NetworkNumber.go | 10 ++++++++++
.../readwrite/model/NetworkProtocolControlInformation.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/NetworkRoute.go | 10 ++++++++++
.../cbus/readwrite/model/NotTransmittedCorruption.go | 10 ++++++++++
.../cbus/readwrite/model/NotTransmittedSyncLoss.go | 10 ++++++++++
.../readwrite/model/NotTransmittedToManyReTransmissions.go | 10 ++++++++++
.../cbus/readwrite/model/NotTransmittedTooLong.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/ParameterChange.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/ParameterChangeReply.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/PowerUp.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/PowerUpReply.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/Reply.go | 14 ++++++++++++--
plc4go/protocols/cbus/readwrite/model/ReplyNetwork.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/SALData.go | 14 ++++++++++++--
plc4go/protocols/cbus/readwrite/model/SALDataOff.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/SALDataOn.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/SALDataRampToLevel.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/SALDataTerminateRamp.go | 10 ++++++++++
.../cbus/readwrite/model/SerialInterfaceAddress.go | 10 ++++++++++
.../cbus/readwrite/model/StandardFormatStatusReply.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/StatusByte.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/StatusHeader.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/StatusRequest.go | 14 ++++++++++++--
.../cbus/readwrite/model/StatusRequestBinaryState.go | 10 ++++++++++
.../protocols/cbus/readwrite/model/StatusRequestLevel.go | 10 ++++++++++
plc4go/protocols/cbus/readwrite/model/UnitAddress.go | 10 ++++++++++
plc4go/protocols/df1/readwrite/model/DF1Command.go | 14 ++++++++++++--
plc4go/protocols/df1/readwrite/model/DF1Symbol.go | 14 ++++++++++++--
.../protocols/df1/readwrite/model/DF1SymbolMessageFrame.go | 10 ++++++++++
.../df1/readwrite/model/DF1SymbolMessageFrameACK.go | 10 ++++++++++
.../df1/readwrite/model/DF1SymbolMessageFrameNAK.go | 10 ++++++++++
.../df1/readwrite/model/DF1UnprotectedReadRequest.go | 10 ++++++++++
.../df1/readwrite/model/DF1UnprotectedReadResponse.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipExchange.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipRRData.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipReadRequest.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipReadResponse.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipService.go | 14 ++++++++++++--
.../protocols/eip/readwrite/model/CipUnconnectedRequest.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipWriteRequest.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/CipWriteResponse.go | 10 ++++++++++
.../protocols/eip/readwrite/model/EipConnectionRequest.go | 10 ++++++++++
.../protocols/eip/readwrite/model/EipDisconnectRequest.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/EipPacket.go | 14 ++++++++++++--
.../eip/readwrite/model/MultipleServiceRequest.go | 10 ++++++++++
.../eip/readwrite/model/MultipleServiceResponse.go | 10 ++++++++++
plc4go/protocols/eip/readwrite/model/Services.go | 10 ++++++++++
plc4go/protocols/firmata/readwrite/model/FirmataCommand.go | 14 ++++++++++++--
.../readwrite/model/FirmataCommandProtocolVersion.go | 10 ++++++++++
.../readwrite/model/FirmataCommandSetDigitalPinValue.go | 10 ++++++++++
.../firmata/readwrite/model/FirmataCommandSetPinMode.go | 10 ++++++++++
.../firmata/readwrite/model/FirmataCommandSysex.go | 10 ++++++++++
.../firmata/readwrite/model/FirmataCommandSystemReset.go | 10 ++++++++++
plc4go/protocols/firmata/readwrite/model/FirmataMessage.go | 14 ++++++++++++--
.../firmata/readwrite/model/FirmataMessageAnalogIO.go | 10 ++++++++++
.../firmata/readwrite/model/FirmataMessageCommand.go | 10 ++++++++++
.../firmata/readwrite/model/FirmataMessageDigitalIO.go | 10 ++++++++++
.../model/FirmataMessageSubscribeAnalogPinValue.go | 10 ++++++++++
.../model/FirmataMessageSubscribeDigitalPinValue.go | 10 ++++++++++
plc4go/protocols/firmata/readwrite/model/SysexCommand.go | 14 ++++++++++++--
.../model/SysexCommandAnalogMappingQueryRequest.go | 10 ++++++++++
.../model/SysexCommandAnalogMappingQueryResponse.go | 10 ++++++++++
.../readwrite/model/SysexCommandAnalogMappingResponse.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandCapabilityQuery.go | 10 ++++++++++
.../readwrite/model/SysexCommandCapabilityResponse.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandExtendedAnalog.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandExtendedId.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandPinStateQuery.go | 10 ++++++++++
.../readwrite/model/SysexCommandPinStateResponse.go | 10 ++++++++++
.../readwrite/model/SysexCommandReportFirmwareRequest.go | 10 ++++++++++
.../readwrite/model/SysexCommandReportFirmwareResponse.go | 10 ++++++++++
.../readwrite/model/SysexCommandSamplingInterval.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandStringData.go | 10 ++++++++++
.../readwrite/model/SysexCommandSysexNonRealtime.go | 10 ++++++++++
.../firmata/readwrite/model/SysexCommandSysexRealtime.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/Apdu.go | 14 ++++++++++++--
plc4go/protocols/knxnetip/readwrite/model/ApduControl.go | 14 ++++++++++++--
.../protocols/knxnetip/readwrite/model/ApduControlAck.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduControlConnect.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduControlContainer.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduControlDisconnect.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/ApduControlNack.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/ApduData.go | 14 ++++++++++++--
.../protocols/knxnetip/readwrite/model/ApduDataAdcRead.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataAdcResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataContainer.go | 10 ++++++++++
.../readwrite/model/ApduDataDeviceDescriptorRead.go | 10 ++++++++++
.../readwrite/model/ApduDataDeviceDescriptorResponse.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/ApduDataExt.go | 14 ++++++++++++--
.../readwrite/model/ApduDataExtAuthorizeRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtAuthorizeResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtDomainAddressRead.go | 10 ++++++++++
.../readwrite/model/ApduDataExtDomainAddressResponse.go | 10 ++++++++++
.../model/ApduDataExtDomainAddressSelectiveRead.go | 10 ++++++++++
.../model/ApduDataExtDomainAddressSerialNumberRead.go | 10 ++++++++++
.../model/ApduDataExtDomainAddressSerialNumberResponse.go | 10 ++++++++++
.../model/ApduDataExtDomainAddressSerialNumberWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataExtDomainAddressWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataExtFileStreamInfoReport.go | 10 ++++++++++
.../model/ApduDataExtGroupPropertyValueInfoReport.go | 10 ++++++++++
.../readwrite/model/ApduDataExtGroupPropertyValueRead.go | 10 ++++++++++
.../model/ApduDataExtGroupPropertyValueResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtGroupPropertyValueWrite.go | 10 ++++++++++
.../model/ApduDataExtIndividualAddressSerialNumberRead.go | 10 ++++++++++
.../ApduDataExtIndividualAddressSerialNumberResponse.go | 10 ++++++++++
.../model/ApduDataExtIndividualAddressSerialNumberWrite.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtKeyResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtKeyWrite.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtLinkRead.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtLinkResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtLinkWrite.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataExtMemoryBitWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataExtNetworkParameterRead.go | 10 ++++++++++
.../readwrite/model/ApduDataExtNetworkParameterResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtNetworkParameterWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataExtOpenRoutingTableRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtPropertyDescriptionRead.go | 10 ++++++++++
.../model/ApduDataExtPropertyDescriptionResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtPropertyValueRead.go | 10 ++++++++++
.../readwrite/model/ApduDataExtPropertyValueResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtPropertyValueWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRouterMemoryRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRouterMemoryResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRouterStatusRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRouterStatusResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRoutingTableRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtReadRoutingTableResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataExtWriteRouterMemoryRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtWriteRouterStatusRequest.go | 10 ++++++++++
.../readwrite/model/ApduDataExtWriteRoutingTableRequest.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataGroupValueRead.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataGroupValueResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataGroupValueWrite.go | 10 ++++++++++
.../readwrite/model/ApduDataIndividualAddressRead.go | 10 ++++++++++
.../readwrite/model/ApduDataIndividualAddressResponse.go | 10 ++++++++++
.../readwrite/model/ApduDataIndividualAddressWrite.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataMemoryRead.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataMemoryResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataMemoryWrite.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/ApduDataOther.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/ApduDataRestart.go | 10 ++++++++++
.../knxnetip/readwrite/model/ApduDataUserMessage.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/CEMI.go | 14 ++++++++++++--
.../knxnetip/readwrite/model/CEMIAdditionalInformation.go | 14 ++++++++++++--
.../model/CEMIAdditionalInformationBusmonitorInfo.go | 10 ++++++++++
.../model/CEMIAdditionalInformationRelativeTimestamp.go | 10 ++++++++++
.../knxnetip/readwrite/model/ChannelInformation.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/ComObjectTable.go | 14 ++++++++++++--
.../readwrite/model/ComObjectTableRealisationType1.go | 10 ++++++++++
.../readwrite/model/ComObjectTableRealisationType2.go | 10 ++++++++++
.../readwrite/model/ComObjectTableRealisationType6.go | 10 ++++++++++
.../knxnetip/readwrite/model/ConnectionRequest.go | 10 ++++++++++
.../readwrite/model/ConnectionRequestInformation.go | 14 ++++++++++++--
.../model/ConnectionRequestInformationDeviceManagement.go | 10 ++++++++++
.../model/ConnectionRequestInformationTunnelConnection.go | 10 ++++++++++
.../knxnetip/readwrite/model/ConnectionResponse.go | 10 ++++++++++
.../readwrite/model/ConnectionResponseDataBlock.go | 14 ++++++++++++--
.../model/ConnectionResponseDataBlockDeviceManagement.go | 10 ++++++++++
.../model/ConnectionResponseDataBlockTunnelConnection.go | 10 ++++++++++
.../knxnetip/readwrite/model/ConnectionStateRequest.go | 10 ++++++++++
.../knxnetip/readwrite/model/ConnectionStateResponse.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/DIBDeviceInfo.go | 10 ++++++++++
.../knxnetip/readwrite/model/DIBSuppSvcFamilies.go | 10 ++++++++++
.../knxnetip/readwrite/model/DescriptionRequest.go | 10 ++++++++++
.../knxnetip/readwrite/model/DescriptionResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/DeviceConfigurationAck.go | 10 ++++++++++
.../readwrite/model/DeviceConfigurationAckDataBlock.go | 10 ++++++++++
.../knxnetip/readwrite/model/DeviceConfigurationRequest.go | 10 ++++++++++
.../readwrite/model/DeviceConfigurationRequestDataBlock.go | 10 ++++++++++
.../knxnetip/readwrite/model/DeviceDescriptorType2.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/DeviceStatus.go | 10 ++++++++++
.../knxnetip/readwrite/model/DisconnectRequest.go | 10 ++++++++++
.../knxnetip/readwrite/model/DisconnectResponse.go | 10 ++++++++++
.../model/GroupObjectDescriptorRealisationType1.go | 10 ++++++++++
.../model/GroupObjectDescriptorRealisationType2.go | 10 ++++++++++
.../model/GroupObjectDescriptorRealisationType6.go | 10 ++++++++++
.../model/GroupObjectDescriptorRealisationType7.go | 10 ++++++++++
.../model/GroupObjectDescriptorRealisationTypeB.go | 10 ++++++++++
.../knxnetip/readwrite/model/HPAIControlEndpoint.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/HPAIDataEndpoint.go | 10 ++++++++++
.../knxnetip/readwrite/model/HPAIDiscoveryEndpoint.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/IPAddress.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/KnxAddress.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/KnxGroupAddress.go | 14 ++++++++++++--
.../knxnetip/readwrite/model/KnxGroupAddress2Level.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxGroupAddress3Level.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxGroupAddressFreeLevel.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/KnxNetIpCore.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxNetIpDeviceManagement.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/KnxNetIpMessage.go | 14 ++++++++++++--
.../protocols/knxnetip/readwrite/model/KnxNetIpRouting.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxNetIpTunneling.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxNetObjectServer.go | 10 ++++++++++
.../model/KnxNetRemoteConfigurationAndDiagnosis.go | 10 ++++++++++
.../knxnetip/readwrite/model/KnxNetRemoteLogging.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LBusmonInd.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LDataCon.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LDataExtended.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LDataFrame.go | 14 ++++++++++++--
plc4go/protocols/knxnetip/readwrite/model/LDataFrameACK.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LDataInd.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LDataReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LPollData.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LPollDataCon.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LPollDataReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LRawCon.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LRawInd.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/LRawReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MACAddress.go | 10 ++++++++++
.../knxnetip/readwrite/model/MFuncPropCommandReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MFuncPropCon.go | 10 ++++++++++
.../knxnetip/readwrite/model/MFuncPropStateReadReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MPropInfoInd.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MPropReadCon.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MPropReadReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MPropWriteCon.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MPropWriteReq.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MResetInd.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/MResetReq.go | 10 ++++++++++
.../readwrite/model/ProjectInstallationIdentifier.go | 10 ++++++++++
.../knxnetip/readwrite/model/RelativeTimestamp.go | 10 ++++++++++
.../knxnetip/readwrite/model/RoutingIndication.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/SearchRequest.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/SearchResponse.go | 10 ++++++++++
plc4go/protocols/knxnetip/readwrite/model/ServiceId.go | 14 ++++++++++++--
.../knxnetip/readwrite/model/TDataConnectedInd.go | 10 ++++++++++
.../knxnetip/readwrite/model/TDataConnectedReq.go | 10 ++++++++++
.../knxnetip/readwrite/model/TDataIndividualInd.go | 10 ++++++++++
.../knxnetip/readwrite/model/TDataIndividualReq.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/TunnelingRequest.go | 10 ++++++++++
.../knxnetip/readwrite/model/TunnelingRequestDataBlock.go | 10 ++++++++++
.../knxnetip/readwrite/model/TunnelingResponse.go | 10 ++++++++++
.../knxnetip/readwrite/model/TunnelingResponseDataBlock.go | 10 ++++++++++
.../protocols/knxnetip/readwrite/model/UnknownMessage.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusADU.go | 14 ++++++++++++--
plc4go/protocols/modbus/readwrite/model/ModbusAsciiADU.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusConstants.go | 10 ++++++++++
.../readwrite/model/ModbusDeviceInformationObject.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusPDU.go | 14 ++++++++++++--
.../modbus/readwrite/model/ModbusPDUDiagnosticRequest.go | 10 ++++++++++
.../modbus/readwrite/model/ModbusPDUDiagnosticResponse.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusPDUError.go | 10 ++++++++++
.../readwrite/model/ModbusPDUGetComEventCounterRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUGetComEventCounterResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUGetComEventLogRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUGetComEventLogResponse.go | 10 ++++++++++
.../model/ModbusPDUMaskWriteHoldingRegisterRequest.go | 10 ++++++++++
.../model/ModbusPDUMaskWriteHoldingRegisterResponse.go | 10 ++++++++++
.../modbus/readwrite/model/ModbusPDUReadCoilsRequest.go | 10 ++++++++++
.../modbus/readwrite/model/ModbusPDUReadCoilsResponse.go | 10 ++++++++++
.../model/ModbusPDUReadDeviceIdentificationRequest.go | 10 ++++++++++
.../model/ModbusPDUReadDeviceIdentificationResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadDiscreteInputsRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadDiscreteInputsResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadExceptionStatusRequest.go | 10 ++++++++++
.../model/ModbusPDUReadExceptionStatusResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFifoQueueRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFifoQueueResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFileRecordRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFileRecordRequestItem.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFileRecordResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadFileRecordResponseItem.go | 10 ++++++++++
.../model/ModbusPDUReadHoldingRegistersRequest.go | 10 ++++++++++
.../model/ModbusPDUReadHoldingRegistersResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadInputRegistersRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReadInputRegistersResponse.go | 10 ++++++++++
.../ModbusPDUReadWriteMultipleHoldingRegistersRequest.go | 10 ++++++++++
.../ModbusPDUReadWriteMultipleHoldingRegistersResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReportServerIdRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUReportServerIdResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteFileRecordRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteFileRecordRequestItem.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteFileRecordResponse.go | 10 ++++++++++
.../model/ModbusPDUWriteFileRecordResponseItem.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteMultipleCoilsRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteMultipleCoilsResponse.go | 10 ++++++++++
.../model/ModbusPDUWriteMultipleHoldingRegistersRequest.go | 10 ++++++++++
.../ModbusPDUWriteMultipleHoldingRegistersResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteSingleCoilRequest.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteSingleCoilResponse.go | 10 ++++++++++
.../readwrite/model/ModbusPDUWriteSingleRegisterRequest.go | 10 ++++++++++
.../model/ModbusPDUWriteSingleRegisterResponse.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusRtuADU.go | 10 ++++++++++
plc4go/protocols/modbus/readwrite/model/ModbusTcpADU.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageAckObjectPushType.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageAckPushType.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageAckResponseType.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/AlarmMessageAckType.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageObjectAckType.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageObjectPushType.go | 10 ++++++++++
.../s7/readwrite/model/AlarmMessageObjectQueryType.go | 10 ++++++++++
.../protocols/s7/readwrite/model/AlarmMessagePushType.go | 10 ++++++++++
.../protocols/s7/readwrite/model/AlarmMessageQueryType.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/AssociatedValueType.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/COTPPacket.go | 14 ++++++++++++--
.../s7/readwrite/model/COTPPacketConnectionRequest.go | 10 ++++++++++
.../s7/readwrite/model/COTPPacketConnectionResponse.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/COTPPacketData.go | 10 ++++++++++
.../s7/readwrite/model/COTPPacketDisconnectRequest.go | 10 ++++++++++
.../s7/readwrite/model/COTPPacketDisconnectResponse.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/COTPPacketTpduError.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/COTPParameter.go | 14 ++++++++++++--
.../s7/readwrite/model/COTPParameterCalledTsap.go | 10 ++++++++++
.../s7/readwrite/model/COTPParameterCallingTsap.go | 10 ++++++++++
.../protocols/s7/readwrite/model/COTPParameterChecksum.go | 10 ++++++++++
.../model/COTPParameterDisconnectAdditionalInformation.go | 10 ++++++++++
.../protocols/s7/readwrite/model/COTPParameterTpduSize.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/DateAndTime.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7Address.go | 14 ++++++++++++--
plc4go/protocols/s7/readwrite/model/S7AddressAny.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7DataAlarmMessage.go | 14 ++++++++++++--
plc4go/protocols/s7/readwrite/model/S7Message.go | 14 ++++++++++++--
.../protocols/s7/readwrite/model/S7MessageObjectRequest.go | 10 ++++++++++
.../s7/readwrite/model/S7MessageObjectResponse.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7MessageRequest.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7MessageResponse.go | 10 ++++++++++
.../protocols/s7/readwrite/model/S7MessageResponseData.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7MessageUserData.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7Parameter.go | 14 ++++++++++++--
.../s7/readwrite/model/S7ParameterModeTransition.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterReadVarRequest.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterReadVarResponse.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterSetupCommunication.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7ParameterUserData.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterUserDataItem.go | 14 ++++++++++++--
.../readwrite/model/S7ParameterUserDataItemCPUFunctions.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterWriteVarRequest.go | 10 ++++++++++
.../s7/readwrite/model/S7ParameterWriteVarResponse.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7Payload.go | 14 ++++++++++++--
plc4go/protocols/s7/readwrite/model/S7PayloadAlarm8.go | 10 ++++++++++
.../protocols/s7/readwrite/model/S7PayloadAlarmAckInd.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadAlarmS.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadAlarmSC.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadAlarmSQ.go | 10 ++++++++++
.../s7/readwrite/model/S7PayloadDiagnosticMessage.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadNotify.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadNotify8.go | 10 ++++++++++
.../s7/readwrite/model/S7PayloadReadVarResponse.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go | 10 ++++++++++
.../protocols/s7/readwrite/model/S7PayloadUserDataItem.go | 14 ++++++++++++--
.../model/S7PayloadUserDataItemCpuFunctionAlarmAck.go | 10 ++++++++++
.../S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go | 10 ++++++++++
.../model/S7PayloadUserDataItemCpuFunctionAlarmQuery.go | 10 ++++++++++
.../S7PayloadUserDataItemCpuFunctionAlarmQueryResponse.go | 10 ++++++++++
.../S7PayloadUserDataItemCpuFunctionMsgSubscription.go | 10 ++++++++++
...dUserDataItemCpuFunctionMsgSubscriptionAlarmResponse.go | 10 ++++++++++
...ayloadUserDataItemCpuFunctionMsgSubscriptionResponse.go | 10 ++++++++++
...oadUserDataItemCpuFunctionMsgSubscriptionSysResponse.go | 10 ++++++++++
.../S7PayloadUserDataItemCpuFunctionReadSzlRequest.go | 10 ++++++++++
.../S7PayloadUserDataItemCpuFunctionReadSzlResponse.go | 10 ++++++++++
.../s7/readwrite/model/S7PayloadWriteVarRequest.go | 10 ++++++++++
.../s7/readwrite/model/S7PayloadWriteVarResponse.go | 10 ++++++++++
.../protocols/s7/readwrite/model/S7VarPayloadDataItem.go | 10 ++++++++++
.../protocols/s7/readwrite/model/S7VarPayloadStatusItem.go | 10 ++++++++++
.../s7/readwrite/model/S7VarRequestParameterItem.go | 14 ++++++++++++--
.../s7/readwrite/model/S7VarRequestParameterItemAddress.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/State.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/SzlDataTreeItem.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/SzlId.go | 10 ++++++++++
plc4go/protocols/s7/readwrite/model/TPKTPacket.go | 10 ++++++++++
plc4go/protocols/simulated/readwrite/model/Dummy.go | 10 ++++++++++
1798 files changed, 18176 insertions(+), 196 deletions(-)
diff --git a/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh
index ca30427cbd..d6880ed993 100644
--- a/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh
+++ b/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh
@@ -108,6 +108,12 @@ type ${type.name} interface {
</#list>
}
+// ${type.name}Exactly can be used when we want exactly this type and not a type which fulfills ${type.name}.
+// This is useful for switch cases.
+type ${type.name}Exactly interface {
+ is${type.name}() bool
+}
+
// _${type.name} is the data-structure of this message
type _${type.name} struct {
<#if type.parentType.isPresent()>
@@ -137,6 +143,7 @@ type _${type.name} struct {
<#if type.isDiscriminatedParentTypeDefinition()>
<#assign discriminatedParentType = type.asComplexTypeDefinition().orElseThrow()>
type _${type.name}ChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
<#list discriminatedParentType.getDiscriminatorNames() as discriminatorName>
@@ -146,7 +153,6 @@ type _${type.name}ChildRequirements interface {
Get${discriminatorName?cap_first}() <#if typeRef.isNonSimpleTypeReference() && !typeRef.isEnumTypeReference()>I</#if>${helper.getLanguageTypeNameForTypeReference(typeRef)}
</#if>
</#list>
- Serialize(writeBuffer utils.WriteBuffer) error
}
</#if>
@@ -202,7 +208,7 @@ type ${type.name}Parent interface {
}
type ${type.name}Child interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
<@compress single_line=true>
InitializeParent(parent ${type.name}
<#if type.getPropertyFields()?has_content>, </#if>
@@ -1826,6 +1832,10 @@ func (m *_${type.name}) Serialize(writeBuffer utils.WriteBuffer) error {
</#if>
}
+func (m *_${type.name}) is${type.name}() bool {
+ return true
+}
+
func (m *_${type.name}) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
index 6d2dafe856..6507082e06 100644
--- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
+++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
@@ -33,6 +33,12 @@ type CIPEncapsulationConnectionRequest interface {
CIPEncapsulationPacket
}
+// CIPEncapsulationConnectionRequestExactly can be used when we want exactly this type and not a type which fulfills CIPEncapsulationConnectionRequest.
+// This is useful for switch cases.
+type CIPEncapsulationConnectionRequestExactly interface {
+ isCIPEncapsulationConnectionRequest() bool
+}
+
// _CIPEncapsulationConnectionRequest is the data-structure of this message
type _CIPEncapsulationConnectionRequest struct {
*_CIPEncapsulationPacket
@@ -138,6 +144,10 @@ func (m *_CIPEncapsulationConnectionRequest) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_CIPEncapsulationConnectionRequest) isCIPEncapsulationConnectionRequest() bool {
+ return true
+}
+
func (m *_CIPEncapsulationConnectionRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
index e92fbd1b8c..fdc48400ba 100644
--- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
+++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
@@ -33,6 +33,12 @@ type CIPEncapsulationConnectionResponse interface {
CIPEncapsulationPacket
}
+// CIPEncapsulationConnectionResponseExactly can be used when we want exactly this type and not a type which fulfills CIPEncapsulationConnectionResponse.
+// This is useful for switch cases.
+type CIPEncapsulationConnectionResponseExactly interface {
+ isCIPEncapsulationConnectionResponse() bool
+}
+
// _CIPEncapsulationConnectionResponse is the data-structure of this message
type _CIPEncapsulationConnectionResponse struct {
*_CIPEncapsulationPacket
@@ -138,6 +144,10 @@ func (m *_CIPEncapsulationConnectionResponse) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_CIPEncapsulationConnectionResponse) isCIPEncapsulationConnectionResponse() bool {
+ return true
+}
+
func (m *_CIPEncapsulationConnectionResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go
index 71721fc498..b6ef93e528 100644
--- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go
+++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go
@@ -43,6 +43,12 @@ type CIPEncapsulationPacket interface {
GetOptions() uint32
}
+// CIPEncapsulationPacketExactly can be used when we want exactly this type and not a type which fulfills CIPEncapsulationPacket.
+// This is useful for switch cases.
+type CIPEncapsulationPacketExactly interface {
+ isCIPEncapsulationPacket() bool
+}
+
// _CIPEncapsulationPacket is the data-structure of this message
type _CIPEncapsulationPacket struct {
_CIPEncapsulationPacketChildRequirements
@@ -53,10 +59,10 @@ type _CIPEncapsulationPacket struct {
}
type _CIPEncapsulationPacketChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetCommandType() uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type CIPEncapsulationPacketParent interface {
@@ -65,7 +71,7 @@ type CIPEncapsulationPacketParent interface {
}
type CIPEncapsulationPacketChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent CIPEncapsulationPacket, sessionHandle uint32, status uint32, senderContext []uint8, options uint32)
GetParent() *CIPEncapsulationPacket
@@ -344,6 +350,10 @@ func (pm *_CIPEncapsulationPacket) SerializeParent(writeBuffer utils.WriteBuffer
return nil
}
+func (m *_CIPEncapsulationPacket) isCIPEncapsulationPacket() bool {
+ return true
+}
+
func (m *_CIPEncapsulationPacket) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadRequest.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadRequest.go
index 649fb8eb53..754e32c4ff 100644
--- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadRequest.go
+++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadRequest.go
@@ -35,6 +35,12 @@ type CIPEncapsulationReadRequest interface {
GetRequest() DF1RequestMessage
}
+// CIPEncapsulationReadRequestExactly can be used when we want exactly this type and not a type which fulfills CIPEncapsulationReadRequest.
+// This is useful for switch cases.
+type CIPEncapsulationReadRequestExactly interface {
+ isCIPEncapsulationReadRequest() bool
+}
+
// _CIPEncapsulationReadRequest is the data-structure of this message
type _CIPEncapsulationReadRequest struct {
*_CIPEncapsulationPacket
@@ -185,6 +191,10 @@ func (m *_CIPEncapsulationReadRequest) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_CIPEncapsulationReadRequest) isCIPEncapsulationReadRequest() bool {
+ return true
+}
+
func (m *_CIPEncapsulationReadRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadResponse.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadResponse.go
index 778c1baf6f..b4cfb6eb7d 100644
--- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadResponse.go
+++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationReadResponse.go
@@ -35,6 +35,12 @@ type CIPEncapsulationReadResponse interface {
GetResponse() DF1ResponseMessage
}
+// CIPEncapsulationReadResponseExactly can be used when we want exactly this type and not a type which fulfills CIPEncapsulationReadResponse.
+// This is useful for switch cases.
+type CIPEncapsulationReadResponseExactly interface {
+ isCIPEncapsulationReadResponse() bool
+}
+
// _CIPEncapsulationReadResponse is the data-structure of this message
type _CIPEncapsulationReadResponse struct {
*_CIPEncapsulationPacket
@@ -188,6 +194,10 @@ func (m *_CIPEncapsulationReadResponse) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_CIPEncapsulationReadResponse) isCIPEncapsulationReadResponse() bool {
+ return true
+}
+
func (m *_CIPEncapsulationReadResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1CommandRequestMessage.go b/plc4go/protocols/abeth/readwrite/model/DF1CommandRequestMessage.go
index 9378d77d78..8cce0b15a5 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1CommandRequestMessage.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1CommandRequestMessage.go
@@ -35,6 +35,12 @@ type DF1CommandRequestMessage interface {
GetCommand() DF1RequestCommand
}
+// DF1CommandRequestMessageExactly can be used when we want exactly this type and not a type which fulfills DF1CommandRequestMessage.
+// This is useful for switch cases.
+type DF1CommandRequestMessageExactly interface {
+ isDF1CommandRequestMessage() bool
+}
+
// _DF1CommandRequestMessage is the data-structure of this message
type _DF1CommandRequestMessage struct {
*_DF1RequestMessage
@@ -185,6 +191,10 @@ func (m *_DF1CommandRequestMessage) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_DF1CommandRequestMessage) isDF1CommandRequestMessage() bool {
+ return true
+}
+
func (m *_DF1CommandRequestMessage) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go b/plc4go/protocols/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
index 49cc269b73..3ee813f970 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
@@ -35,6 +35,12 @@ type DF1CommandResponseMessageProtectedTypedLogicalRead interface {
GetData() []uint8
}
+// DF1CommandResponseMessageProtectedTypedLogicalReadExactly can be used when we want exactly this type and not a type which fulfills DF1CommandResponseMessageProtectedTypedLogicalRead.
+// This is useful for switch cases.
+type DF1CommandResponseMessageProtectedTypedLogicalReadExactly interface {
+ isDF1CommandResponseMessageProtectedTypedLogicalRead() bool
+}
+
// _DF1CommandResponseMessageProtectedTypedLogicalRead is the data-structure of this message
type _DF1CommandResponseMessageProtectedTypedLogicalRead struct {
*_DF1ResponseMessage
@@ -202,6 +208,10 @@ func (m *_DF1CommandResponseMessageProtectedTypedLogicalRead) Serialize(writeBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_DF1CommandResponseMessageProtectedTypedLogicalRead) isDF1CommandResponseMessageProtectedTypedLogicalRead() bool {
+ return true
+}
+
func (m *_DF1CommandResponseMessageProtectedTypedLogicalRead) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1RequestCommand.go b/plc4go/protocols/abeth/readwrite/model/DF1RequestCommand.go
index 92c08067ca..943a48be29 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1RequestCommand.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1RequestCommand.go
@@ -34,16 +34,22 @@ type DF1RequestCommand interface {
GetFunctionCode() uint8
}
+// DF1RequestCommandExactly can be used when we want exactly this type and not a type which fulfills DF1RequestCommand.
+// This is useful for switch cases.
+type DF1RequestCommandExactly interface {
+ isDF1RequestCommand() bool
+}
+
// _DF1RequestCommand is the data-structure of this message
type _DF1RequestCommand struct {
_DF1RequestCommandChildRequirements
}
type _DF1RequestCommandChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetFunctionCode() uint8
- Serialize(writeBuffer utils.WriteBuffer) error
}
type DF1RequestCommandParent interface {
@@ -52,7 +58,7 @@ type DF1RequestCommandParent interface {
}
type DF1RequestCommandChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent DF1RequestCommand)
GetParent() *DF1RequestCommand
@@ -166,6 +172,10 @@ func (pm *_DF1RequestCommand) SerializeParent(writeBuffer utils.WriteBuffer, chi
return nil
}
+func (m *_DF1RequestCommand) isDF1RequestCommand() bool {
+ return true
+}
+
func (m *_DF1RequestCommand) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1RequestMessage.go b/plc4go/protocols/abeth/readwrite/model/DF1RequestMessage.go
index 0002b1883e..48c17afe29 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1RequestMessage.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1RequestMessage.go
@@ -43,6 +43,12 @@ type DF1RequestMessage interface {
GetTransactionCounter() uint16
}
+// DF1RequestMessageExactly can be used when we want exactly this type and not a type which fulfills DF1RequestMessage.
+// This is useful for switch cases.
+type DF1RequestMessageExactly interface {
+ isDF1RequestMessage() bool
+}
+
// _DF1RequestMessage is the data-structure of this message
type _DF1RequestMessage struct {
_DF1RequestMessageChildRequirements
@@ -53,10 +59,10 @@ type _DF1RequestMessage struct {
}
type _DF1RequestMessageChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetCommandCode() uint8
- Serialize(writeBuffer utils.WriteBuffer) error
}
type DF1RequestMessageParent interface {
@@ -65,7 +71,7 @@ type DF1RequestMessageParent interface {
}
type DF1RequestMessageChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent DF1RequestMessage, destinationAddress uint8, sourceAddress uint8, status uint8, transactionCounter uint16)
GetParent() *DF1RequestMessage
@@ -298,6 +304,10 @@ func (pm *_DF1RequestMessage) SerializeParent(writeBuffer utils.WriteBuffer, chi
return nil
}
+func (m *_DF1RequestMessage) isDF1RequestMessage() bool {
+ return true
+}
+
func (m *_DF1RequestMessage) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go b/plc4go/protocols/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
index 7d899e8798..e64b18184a 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
@@ -43,6 +43,12 @@ type DF1RequestProtectedTypedLogicalRead interface {
GetSubElementNumber() uint8
}
+// DF1RequestProtectedTypedLogicalReadExactly can be used when we want exactly this type and not a type which fulfills DF1RequestProtectedTypedLogicalRead.
+// This is useful for switch cases.
+type DF1RequestProtectedTypedLogicalReadExactly interface {
+ isDF1RequestProtectedTypedLogicalRead() bool
+}
+
// _DF1RequestProtectedTypedLogicalRead is the data-structure of this message
type _DF1RequestProtectedTypedLogicalRead struct {
*_DF1RequestCommand
@@ -273,6 +279,10 @@ func (m *_DF1RequestProtectedTypedLogicalRead) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_DF1RequestProtectedTypedLogicalRead) isDF1RequestProtectedTypedLogicalRead() bool {
+ return true
+}
+
func (m *_DF1RequestProtectedTypedLogicalRead) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/abeth/readwrite/model/DF1ResponseMessage.go b/plc4go/protocols/abeth/readwrite/model/DF1ResponseMessage.go
index 77cc78ff75..b9c37857e3 100644
--- a/plc4go/protocols/abeth/readwrite/model/DF1ResponseMessage.go
+++ b/plc4go/protocols/abeth/readwrite/model/DF1ResponseMessage.go
@@ -43,6 +43,12 @@ type DF1ResponseMessage interface {
GetTransactionCounter() uint16
}
+// DF1ResponseMessageExactly can be used when we want exactly this type and not a type which fulfills DF1ResponseMessage.
+// This is useful for switch cases.
+type DF1ResponseMessageExactly interface {
+ isDF1ResponseMessage() bool
+}
+
// _DF1ResponseMessage is the data-structure of this message
type _DF1ResponseMessage struct {
_DF1ResponseMessageChildRequirements
@@ -56,10 +62,10 @@ type _DF1ResponseMessage struct {
}
type _DF1ResponseMessageChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetCommandCode() uint8
- Serialize(writeBuffer utils.WriteBuffer) error
}
type DF1ResponseMessageParent interface {
@@ -68,7 +74,7 @@ type DF1ResponseMessageParent interface {
}
type DF1ResponseMessageChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent DF1ResponseMessage, destinationAddress uint8, sourceAddress uint8, status uint8, transactionCounter uint16)
GetParent() *DF1ResponseMessage
@@ -326,6 +332,10 @@ func (pm *_DF1ResponseMessage) SerializeParent(writeBuffer utils.WriteBuffer, ch
return nil
}
+func (m *_DF1ResponseMessage) isDF1ResponseMessage() bool {
+ return true
+}
+
func (m *_DF1ResponseMessage) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationRequest.go b/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
index b47e0cf36a..906fc33c3b 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
@@ -46,6 +46,12 @@ type AdsAddDeviceNotificationRequest interface {
GetCycleTime() uint32
}
+// AdsAddDeviceNotificationRequestExactly can be used when we want exactly this type and not a type which fulfills AdsAddDeviceNotificationRequest.
+// This is useful for switch cases.
+type AdsAddDeviceNotificationRequestExactly interface {
+ isAdsAddDeviceNotificationRequest() bool
+}
+
// _AdsAddDeviceNotificationRequest is the data-structure of this message
type _AdsAddDeviceNotificationRequest struct {
*_AdsData
@@ -354,6 +360,10 @@ func (m *_AdsAddDeviceNotificationRequest) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsAddDeviceNotificationRequest) isAdsAddDeviceNotificationRequest() bool {
+ return true
+}
+
func (m *_AdsAddDeviceNotificationRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationResponse.go b/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
index 5058862bf3..0f8f63354b 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
@@ -37,6 +37,12 @@ type AdsAddDeviceNotificationResponse interface {
GetNotificationHandle() uint32
}
+// AdsAddDeviceNotificationResponseExactly can be used when we want exactly this type and not a type which fulfills AdsAddDeviceNotificationResponse.
+// This is useful for switch cases.
+type AdsAddDeviceNotificationResponseExactly interface {
+ isAdsAddDeviceNotificationResponse() bool
+}
+
// _AdsAddDeviceNotificationResponse is the data-structure of this message
type _AdsAddDeviceNotificationResponse struct {
*_AdsData
@@ -210,6 +216,10 @@ func (m *_AdsAddDeviceNotificationResponse) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsAddDeviceNotificationResponse) isAdsAddDeviceNotificationResponse() bool {
+ return true
+}
+
func (m *_AdsAddDeviceNotificationResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsData.go b/plc4go/protocols/ads/readwrite/model/AdsData.go
index ca9d69e764..16b90afd79 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsData.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsData.go
@@ -36,17 +36,23 @@ type AdsData interface {
GetResponse() bool
}
+// AdsDataExactly can be used when we want exactly this type and not a type which fulfills AdsData.
+// This is useful for switch cases.
+type AdsDataExactly interface {
+ isAdsData() bool
+}
+
// _AdsData is the data-structure of this message
type _AdsData struct {
_AdsDataChildRequirements
}
type _AdsDataChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetCommandId() CommandId
GetResponse() bool
- Serialize(writeBuffer utils.WriteBuffer) error
}
type AdsDataParent interface {
@@ -55,7 +61,7 @@ type AdsDataParent interface {
}
type AdsDataChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent AdsData)
GetParent() *AdsData
@@ -191,6 +197,10 @@ func (pm *_AdsData) SerializeParent(writeBuffer utils.WriteBuffer, child AdsData
return nil
}
+func (m *_AdsData) isAdsData() bool {
+ return true
+}
+
func (m *_AdsData) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go b/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
index f68af6bcd7..d776e216a7 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
@@ -35,6 +35,12 @@ type AdsDeleteDeviceNotificationRequest interface {
GetNotificationHandle() uint32
}
+// AdsDeleteDeviceNotificationRequestExactly can be used when we want exactly this type and not a type which fulfills AdsDeleteDeviceNotificationRequest.
+// This is useful for switch cases.
+type AdsDeleteDeviceNotificationRequestExactly interface {
+ isAdsDeleteDeviceNotificationRequest() bool
+}
+
// _AdsDeleteDeviceNotificationRequest is the data-structure of this message
type _AdsDeleteDeviceNotificationRequest struct {
*_AdsData
@@ -173,6 +179,10 @@ func (m *_AdsDeleteDeviceNotificationRequest) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsDeleteDeviceNotificationRequest) isAdsDeleteDeviceNotificationRequest() bool {
+ return true
+}
+
func (m *_AdsDeleteDeviceNotificationRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go b/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
index 6af7a2380c..b69e95a5ea 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
@@ -35,6 +35,12 @@ type AdsDeleteDeviceNotificationResponse interface {
GetResult() ReturnCode
}
+// AdsDeleteDeviceNotificationResponseExactly can be used when we want exactly this type and not a type which fulfills AdsDeleteDeviceNotificationResponse.
+// This is useful for switch cases.
+type AdsDeleteDeviceNotificationResponseExactly interface {
+ isAdsDeleteDeviceNotificationResponse() bool
+}
+
// _AdsDeleteDeviceNotificationResponse is the data-structure of this message
type _AdsDeleteDeviceNotificationResponse struct {
*_AdsData
@@ -184,6 +190,10 @@ func (m *_AdsDeleteDeviceNotificationResponse) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsDeleteDeviceNotificationResponse) isAdsDeleteDeviceNotificationResponse() bool {
+ return true
+}
+
func (m *_AdsDeleteDeviceNotificationResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go
index 1526063228..6fdc2e5c33 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go
@@ -39,6 +39,12 @@ type AdsDeviceNotificationRequest interface {
GetAdsStampHeaders() []AdsStampHeader
}
+// AdsDeviceNotificationRequestExactly can be used when we want exactly this type and not a type which fulfills AdsDeviceNotificationRequest.
+// This is useful for switch cases.
+type AdsDeviceNotificationRequestExactly interface {
+ isAdsDeviceNotificationRequest() bool
+}
+
// _AdsDeviceNotificationRequest is the data-structure of this message
type _AdsDeviceNotificationRequest struct {
*_AdsData
@@ -251,6 +257,10 @@ func (m *_AdsDeviceNotificationRequest) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsDeviceNotificationRequest) isAdsDeviceNotificationRequest() bool {
+ return true
+}
+
func (m *_AdsDeviceNotificationRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationResponse.go b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationResponse.go
index 046a6aac03..d620805a23 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationResponse.go
@@ -33,6 +33,12 @@ type AdsDeviceNotificationResponse interface {
AdsData
}
+// AdsDeviceNotificationResponseExactly can be used when we want exactly this type and not a type which fulfills AdsDeviceNotificationResponse.
+// This is useful for switch cases.
+type AdsDeviceNotificationResponseExactly interface {
+ isAdsDeviceNotificationResponse() bool
+}
+
// _AdsDeviceNotificationResponse is the data-structure of this message
type _AdsDeviceNotificationResponse struct {
*_AdsData
@@ -137,6 +143,10 @@ func (m *_AdsDeviceNotificationResponse) Serialize(writeBuffer utils.WriteBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsDeviceNotificationResponse) isAdsDeviceNotificationResponse() bool {
+ return true
+}
+
func (m *_AdsDeviceNotificationResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsInvalidRequest.go b/plc4go/protocols/ads/readwrite/model/AdsInvalidRequest.go
index 12d932a8c3..445e10049a 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsInvalidRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsInvalidRequest.go
@@ -33,6 +33,12 @@ type AdsInvalidRequest interface {
AdsData
}
+// AdsInvalidRequestExactly can be used when we want exactly this type and not a type which fulfills AdsInvalidRequest.
+// This is useful for switch cases.
+type AdsInvalidRequestExactly interface {
+ isAdsInvalidRequest() bool
+}
+
// _AdsInvalidRequest is the data-structure of this message
type _AdsInvalidRequest struct {
*_AdsData
@@ -137,6 +143,10 @@ func (m *_AdsInvalidRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsInvalidRequest) isAdsInvalidRequest() bool {
+ return true
+}
+
func (m *_AdsInvalidRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsInvalidResponse.go b/plc4go/protocols/ads/readwrite/model/AdsInvalidResponse.go
index 8f19dccee8..3fdae3cb25 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsInvalidResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsInvalidResponse.go
@@ -33,6 +33,12 @@ type AdsInvalidResponse interface {
AdsData
}
+// AdsInvalidResponseExactly can be used when we want exactly this type and not a type which fulfills AdsInvalidResponse.
+// This is useful for switch cases.
+type AdsInvalidResponseExactly interface {
+ isAdsInvalidResponse() bool
+}
+
// _AdsInvalidResponse is the data-structure of this message
type _AdsInvalidResponse struct {
*_AdsData
@@ -137,6 +143,10 @@ func (m *_AdsInvalidResponse) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsInvalidResponse) isAdsInvalidResponse() bool {
+ return true
+}
+
func (m *_AdsInvalidResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItem.go b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItem.go
index b54d07f355..6cf55255fb 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItem.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItem.go
@@ -34,16 +34,22 @@ type AdsMultiRequestItem interface {
GetIndexGroup() uint32
}
+// AdsMultiRequestItemExactly can be used when we want exactly this type and not a type which fulfills AdsMultiRequestItem.
+// This is useful for switch cases.
+type AdsMultiRequestItemExactly interface {
+ isAdsMultiRequestItem() bool
+}
+
// _AdsMultiRequestItem is the data-structure of this message
type _AdsMultiRequestItem struct {
_AdsMultiRequestItemChildRequirements
}
type _AdsMultiRequestItemChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetIndexGroup() uint32
- Serialize(writeBuffer utils.WriteBuffer) error
}
type AdsMultiRequestItemParent interface {
@@ -52,7 +58,7 @@ type AdsMultiRequestItemParent interface {
}
type AdsMultiRequestItemChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent AdsMultiRequestItem)
GetParent() *AdsMultiRequestItem
@@ -154,6 +160,10 @@ func (pm *_AdsMultiRequestItem) SerializeParent(writeBuffer utils.WriteBuffer, c
return nil
}
+func (m *_AdsMultiRequestItem) isAdsMultiRequestItem() bool {
+ return true
+}
+
func (m *_AdsMultiRequestItem) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemRead.go b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemRead.go
index 3db7caf0cf..c8714ca555 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemRead.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemRead.go
@@ -39,6 +39,12 @@ type AdsMultiRequestItemRead interface {
GetItemReadLength() uint32
}
+// AdsMultiRequestItemReadExactly can be used when we want exactly this type and not a type which fulfills AdsMultiRequestItemRead.
+// This is useful for switch cases.
+type AdsMultiRequestItemReadExactly interface {
+ isAdsMultiRequestItemRead() bool
+}
+
// _AdsMultiRequestItemRead is the data-structure of this message
type _AdsMultiRequestItemRead struct {
*_AdsMultiRequestItem
@@ -221,6 +227,10 @@ func (m *_AdsMultiRequestItemRead) Serialize(writeBuffer utils.WriteBuffer) erro
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsMultiRequestItemRead) isAdsMultiRequestItemRead() bool {
+ return true
+}
+
func (m *_AdsMultiRequestItemRead) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemReadWrite.go b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
index 1444d059c0..cd535c3f18 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
@@ -41,6 +41,12 @@ type AdsMultiRequestItemReadWrite interface {
GetItemWriteLength() uint32
}
+// AdsMultiRequestItemReadWriteExactly can be used when we want exactly this type and not a type which fulfills AdsMultiRequestItemReadWrite.
+// This is useful for switch cases.
+type AdsMultiRequestItemReadWriteExactly interface {
+ isAdsMultiRequestItemReadWrite() bool
+}
+
// _AdsMultiRequestItemReadWrite is the data-structure of this message
type _AdsMultiRequestItemReadWrite struct {
*_AdsMultiRequestItem
@@ -247,6 +253,10 @@ func (m *_AdsMultiRequestItemReadWrite) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsMultiRequestItemReadWrite) isAdsMultiRequestItemReadWrite() bool {
+ return true
+}
+
func (m *_AdsMultiRequestItemReadWrite) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemWrite.go b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemWrite.go
index e209310647..77bdde0386 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemWrite.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsMultiRequestItemWrite.go
@@ -39,6 +39,12 @@ type AdsMultiRequestItemWrite interface {
GetItemWriteLength() uint32
}
+// AdsMultiRequestItemWriteExactly can be used when we want exactly this type and not a type which fulfills AdsMultiRequestItemWrite.
+// This is useful for switch cases.
+type AdsMultiRequestItemWriteExactly interface {
+ isAdsMultiRequestItemWrite() bool
+}
+
// _AdsMultiRequestItemWrite is the data-structure of this message
type _AdsMultiRequestItemWrite struct {
*_AdsMultiRequestItem
@@ -221,6 +227,10 @@ func (m *_AdsMultiRequestItemWrite) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsMultiRequestItemWrite) isAdsMultiRequestItemWrite() bool {
+ return true
+}
+
func (m *_AdsMultiRequestItemWrite) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsNotificationSample.go b/plc4go/protocols/ads/readwrite/model/AdsNotificationSample.go
index cea8d3d42a..d0324e905d 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsNotificationSample.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsNotificationSample.go
@@ -38,6 +38,12 @@ type AdsNotificationSample interface {
GetData() []byte
}
+// AdsNotificationSampleExactly can be used when we want exactly this type and not a type which fulfills AdsNotificationSample.
+// This is useful for switch cases.
+type AdsNotificationSampleExactly interface {
+ isAdsNotificationSample() bool
+}
+
// _AdsNotificationSample is the data-structure of this message
type _AdsNotificationSample struct {
NotificationHandle uint32
@@ -185,6 +191,10 @@ func (m *_AdsNotificationSample) Serialize(writeBuffer utils.WriteBuffer) error
return nil
}
+func (m *_AdsNotificationSample) isAdsNotificationSample() bool {
+ return true
+}
+
func (m *_AdsNotificationSample) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoRequest.go b/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoRequest.go
index 2bff6cf780..19ee7fc44e 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoRequest.go
@@ -33,6 +33,12 @@ type AdsReadDeviceInfoRequest interface {
AdsData
}
+// AdsReadDeviceInfoRequestExactly can be used when we want exactly this type and not a type which fulfills AdsReadDeviceInfoRequest.
+// This is useful for switch cases.
+type AdsReadDeviceInfoRequestExactly interface {
+ isAdsReadDeviceInfoRequest() bool
+}
+
// _AdsReadDeviceInfoRequest is the data-structure of this message
type _AdsReadDeviceInfoRequest struct {
*_AdsData
@@ -137,6 +143,10 @@ func (m *_AdsReadDeviceInfoRequest) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadDeviceInfoRequest) isAdsReadDeviceInfoRequest() bool {
+ return true
+}
+
func (m *_AdsReadDeviceInfoRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoResponse.go b/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoResponse.go
index 26221af71b..6a28412b61 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadDeviceInfoResponse.go
@@ -43,6 +43,12 @@ type AdsReadDeviceInfoResponse interface {
GetDevice() []byte
}
+// AdsReadDeviceInfoResponseExactly can be used when we want exactly this type and not a type which fulfills AdsReadDeviceInfoResponse.
+// This is useful for switch cases.
+type AdsReadDeviceInfoResponseExactly interface {
+ isAdsReadDeviceInfoResponse() bool
+}
+
// _AdsReadDeviceInfoResponse is the data-structure of this message
type _AdsReadDeviceInfoResponse struct {
*_AdsData
@@ -291,6 +297,10 @@ func (m *_AdsReadDeviceInfoResponse) Serialize(writeBuffer utils.WriteBuffer) er
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadDeviceInfoResponse) isAdsReadDeviceInfoResponse() bool {
+ return true
+}
+
func (m *_AdsReadDeviceInfoResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadRequest.go b/plc4go/protocols/ads/readwrite/model/AdsReadRequest.go
index a829c2231d..3aa4642b25 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadRequest.go
@@ -39,6 +39,12 @@ type AdsReadRequest interface {
GetLength() uint32
}
+// AdsReadRequestExactly can be used when we want exactly this type and not a type which fulfills AdsReadRequest.
+// This is useful for switch cases.
+type AdsReadRequestExactly interface {
+ isAdsReadRequest() bool
+}
+
// _AdsReadRequest is the data-structure of this message
type _AdsReadRequest struct {
*_AdsData
@@ -225,6 +231,10 @@ func (m *_AdsReadRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadRequest) isAdsReadRequest() bool {
+ return true
+}
+
func (m *_AdsReadRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadResponse.go b/plc4go/protocols/ads/readwrite/model/AdsReadResponse.go
index b96bd48292..723236eb5f 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadResponse.go
@@ -37,6 +37,12 @@ type AdsReadResponse interface {
GetData() []byte
}
+// AdsReadResponseExactly can be used when we want exactly this type and not a type which fulfills AdsReadResponse.
+// This is useful for switch cases.
+type AdsReadResponseExactly interface {
+ isAdsReadResponse() bool
+}
+
// _AdsReadResponse is the data-structure of this message
type _AdsReadResponse struct {
*_AdsData
@@ -230,6 +236,10 @@ func (m *_AdsReadResponse) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadResponse) isAdsReadResponse() bool {
+ return true
+}
+
func (m *_AdsReadResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadStateRequest.go b/plc4go/protocols/ads/readwrite/model/AdsReadStateRequest.go
index 439b75da68..31c71c20f5 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadStateRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadStateRequest.go
@@ -33,6 +33,12 @@ type AdsReadStateRequest interface {
AdsData
}
+// AdsReadStateRequestExactly can be used when we want exactly this type and not a type which fulfills AdsReadStateRequest.
+// This is useful for switch cases.
+type AdsReadStateRequestExactly interface {
+ isAdsReadStateRequest() bool
+}
+
// _AdsReadStateRequest is the data-structure of this message
type _AdsReadStateRequest struct {
*_AdsData
@@ -137,6 +143,10 @@ func (m *_AdsReadStateRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadStateRequest) isAdsReadStateRequest() bool {
+ return true
+}
+
func (m *_AdsReadStateRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadStateResponse.go b/plc4go/protocols/ads/readwrite/model/AdsReadStateResponse.go
index d065323955..6b25cf1984 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadStateResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadStateResponse.go
@@ -39,6 +39,12 @@ type AdsReadStateResponse interface {
GetDeviceState() uint16
}
+// AdsReadStateResponseExactly can be used when we want exactly this type and not a type which fulfills AdsReadStateResponse.
+// This is useful for switch cases.
+type AdsReadStateResponseExactly interface {
+ isAdsReadStateResponse() bool
+}
+
// _AdsReadStateResponse is the data-structure of this message
type _AdsReadStateResponse struct {
*_AdsData
@@ -236,6 +242,10 @@ func (m *_AdsReadStateResponse) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadStateResponse) isAdsReadStateResponse() bool {
+ return true
+}
+
func (m *_AdsReadStateResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go b/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go
index a3cfa48f97..324d3f3a7e 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go
@@ -43,6 +43,12 @@ type AdsReadWriteRequest interface {
GetData() []byte
}
+// AdsReadWriteRequestExactly can be used when we want exactly this type and not a type which fulfills AdsReadWriteRequest.
+// This is useful for switch cases.
+type AdsReadWriteRequestExactly interface {
+ isAdsReadWriteRequest() bool
+}
+
// _AdsReadWriteRequest is the data-structure of this message
type _AdsReadWriteRequest struct {
*_AdsData
@@ -323,6 +329,10 @@ func (m *_AdsReadWriteRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadWriteRequest) isAdsReadWriteRequest() bool {
+ return true
+}
+
func (m *_AdsReadWriteRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadWriteResponse.go b/plc4go/protocols/ads/readwrite/model/AdsReadWriteResponse.go
index bb0d63c49b..b5a1dbf65c 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsReadWriteResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsReadWriteResponse.go
@@ -37,6 +37,12 @@ type AdsReadWriteResponse interface {
GetData() []byte
}
+// AdsReadWriteResponseExactly can be used when we want exactly this type and not a type which fulfills AdsReadWriteResponse.
+// This is useful for switch cases.
+type AdsReadWriteResponseExactly interface {
+ isAdsReadWriteResponse() bool
+}
+
// _AdsReadWriteResponse is the data-structure of this message
type _AdsReadWriteResponse struct {
*_AdsData
@@ -230,6 +236,10 @@ func (m *_AdsReadWriteResponse) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsReadWriteResponse) isAdsReadWriteResponse() bool {
+ return true
+}
+
func (m *_AdsReadWriteResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go b/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go
index a03714adae..f09189e0d4 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go
@@ -38,6 +38,12 @@ type AdsStampHeader interface {
GetAdsNotificationSamples() []AdsNotificationSample
}
+// AdsStampHeaderExactly can be used when we want exactly this type and not a type which fulfills AdsStampHeader.
+// This is useful for switch cases.
+type AdsStampHeaderExactly interface {
+ isAdsStampHeader() bool
+}
+
// _AdsStampHeader is the data-structure of this message
type _AdsStampHeader struct {
Timestamp uint64
@@ -208,6 +214,10 @@ func (m *_AdsStampHeader) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AdsStampHeader) isAdsStampHeader() bool {
+ return true
+}
+
func (m *_AdsStampHeader) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsWriteControlRequest.go b/plc4go/protocols/ads/readwrite/model/AdsWriteControlRequest.go
index 76f9952102..2c1e13a3d8 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsWriteControlRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsWriteControlRequest.go
@@ -39,6 +39,12 @@ type AdsWriteControlRequest interface {
GetData() []byte
}
+// AdsWriteControlRequestExactly can be used when we want exactly this type and not a type which fulfills AdsWriteControlRequest.
+// This is useful for switch cases.
+type AdsWriteControlRequestExactly interface {
+ isAdsWriteControlRequest() bool
+}
+
// _AdsWriteControlRequest is the data-structure of this message
type _AdsWriteControlRequest struct {
*_AdsData
@@ -245,6 +251,10 @@ func (m *_AdsWriteControlRequest) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsWriteControlRequest) isAdsWriteControlRequest() bool {
+ return true
+}
+
func (m *_AdsWriteControlRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsWriteControlResponse.go b/plc4go/protocols/ads/readwrite/model/AdsWriteControlResponse.go
index e557aff5fb..ebc61b2858 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsWriteControlResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsWriteControlResponse.go
@@ -35,6 +35,12 @@ type AdsWriteControlResponse interface {
GetResult() ReturnCode
}
+// AdsWriteControlResponseExactly can be used when we want exactly this type and not a type which fulfills AdsWriteControlResponse.
+// This is useful for switch cases.
+type AdsWriteControlResponseExactly interface {
+ isAdsWriteControlResponse() bool
+}
+
// _AdsWriteControlResponse is the data-structure of this message
type _AdsWriteControlResponse struct {
*_AdsData
@@ -184,6 +190,10 @@ func (m *_AdsWriteControlResponse) Serialize(writeBuffer utils.WriteBuffer) erro
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsWriteControlResponse) isAdsWriteControlResponse() bool {
+ return true
+}
+
func (m *_AdsWriteControlResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsWriteRequest.go b/plc4go/protocols/ads/readwrite/model/AdsWriteRequest.go
index 6f619b3aee..cef1c53127 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsWriteRequest.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsWriteRequest.go
@@ -39,6 +39,12 @@ type AdsWriteRequest interface {
GetData() []byte
}
+// AdsWriteRequestExactly can be used when we want exactly this type and not a type which fulfills AdsWriteRequest.
+// This is useful for switch cases.
+type AdsWriteRequestExactly interface {
+ isAdsWriteRequest() bool
+}
+
// _AdsWriteRequest is the data-structure of this message
type _AdsWriteRequest struct {
*_AdsData
@@ -245,6 +251,10 @@ func (m *_AdsWriteRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsWriteRequest) isAdsWriteRequest() bool {
+ return true
+}
+
func (m *_AdsWriteRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AdsWriteResponse.go b/plc4go/protocols/ads/readwrite/model/AdsWriteResponse.go
index e66f501d76..ccd0e9fe6c 100644
--- a/plc4go/protocols/ads/readwrite/model/AdsWriteResponse.go
+++ b/plc4go/protocols/ads/readwrite/model/AdsWriteResponse.go
@@ -35,6 +35,12 @@ type AdsWriteResponse interface {
GetResult() ReturnCode
}
+// AdsWriteResponseExactly can be used when we want exactly this type and not a type which fulfills AdsWriteResponse.
+// This is useful for switch cases.
+type AdsWriteResponseExactly interface {
+ isAdsWriteResponse() bool
+}
+
// _AdsWriteResponse is the data-structure of this message
type _AdsWriteResponse struct {
*_AdsData
@@ -184,6 +190,10 @@ func (m *_AdsWriteResponse) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_AdsWriteResponse) isAdsWriteResponse() bool {
+ return true
+}
+
func (m *_AdsWriteResponse) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsNetId.go b/plc4go/protocols/ads/readwrite/model/AmsNetId.go
index ceeb1f6ad6..39935437a7 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsNetId.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsNetId.go
@@ -44,6 +44,12 @@ type AmsNetId interface {
GetOctet6() uint8
}
+// AmsNetIdExactly can be used when we want exactly this type and not a type which fulfills AmsNetId.
+// This is useful for switch cases.
+type AmsNetIdExactly interface {
+ isAmsNetId() bool
+}
+
// _AmsNetId is the data-structure of this message
type _AmsNetId struct {
Octet1 uint8
@@ -254,6 +260,10 @@ func (m *_AmsNetId) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AmsNetId) isAmsNetId() bool {
+ return true
+}
+
func (m *_AmsNetId) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsPacket.go b/plc4go/protocols/ads/readwrite/model/AmsPacket.go
index 3ecb0b13f1..1403c179d3 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsPacket.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsPacket.go
@@ -50,6 +50,12 @@ type AmsPacket interface {
GetData() AdsData
}
+// AmsPacketExactly can be used when we want exactly this type and not a type which fulfills AmsPacket.
+// This is useful for switch cases.
+type AmsPacketExactly interface {
+ isAmsPacket() bool
+}
+
// _AmsPacket is the data-structure of this message
type _AmsPacket struct {
TargetAmsNetId AmsNetId
@@ -398,6 +404,10 @@ func (m *_AmsPacket) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AmsPacket) isAmsPacket() bool {
+ return true
+}
+
func (m *_AmsPacket) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsSerialAcknowledgeFrame.go b/plc4go/protocols/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
index c2d80ca855..f3d5206e05 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
@@ -44,6 +44,12 @@ type AmsSerialAcknowledgeFrame interface {
GetCrc() uint16
}
+// AmsSerialAcknowledgeFrameExactly can be used when we want exactly this type and not a type which fulfills AmsSerialAcknowledgeFrame.
+// This is useful for switch cases.
+type AmsSerialAcknowledgeFrameExactly interface {
+ isAmsSerialAcknowledgeFrame() bool
+}
+
// _AmsSerialAcknowledgeFrame is the data-structure of this message
type _AmsSerialAcknowledgeFrame struct {
MagicCookie uint16
@@ -254,6 +260,10 @@ func (m *_AmsSerialAcknowledgeFrame) Serialize(writeBuffer utils.WriteBuffer) er
return nil
}
+func (m *_AmsSerialAcknowledgeFrame) isAmsSerialAcknowledgeFrame() bool {
+ return true
+}
+
func (m *_AmsSerialAcknowledgeFrame) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsSerialFrame.go b/plc4go/protocols/ads/readwrite/model/AmsSerialFrame.go
index 5dc3f9a22f..7b8e988763 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsSerialFrame.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsSerialFrame.go
@@ -46,6 +46,12 @@ type AmsSerialFrame interface {
GetCrc() uint16
}
+// AmsSerialFrameExactly can be used when we want exactly this type and not a type which fulfills AmsSerialFrame.
+// This is useful for switch cases.
+type AmsSerialFrameExactly interface {
+ isAmsSerialFrame() bool
+}
+
// _AmsSerialFrame is the data-structure of this message
type _AmsSerialFrame struct {
MagicCookie uint16
@@ -289,6 +295,10 @@ func (m *_AmsSerialFrame) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AmsSerialFrame) isAmsSerialFrame() bool {
+ return true
+}
+
func (m *_AmsSerialFrame) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsSerialResetFrame.go b/plc4go/protocols/ads/readwrite/model/AmsSerialResetFrame.go
index cae852a52e..7ffa0d833a 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsSerialResetFrame.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsSerialResetFrame.go
@@ -44,6 +44,12 @@ type AmsSerialResetFrame interface {
GetCrc() uint16
}
+// AmsSerialResetFrameExactly can be used when we want exactly this type and not a type which fulfills AmsSerialResetFrame.
+// This is useful for switch cases.
+type AmsSerialResetFrameExactly interface {
+ isAmsSerialResetFrame() bool
+}
+
// _AmsSerialResetFrame is the data-structure of this message
type _AmsSerialResetFrame struct {
MagicCookie uint16
@@ -254,6 +260,10 @@ func (m *_AmsSerialResetFrame) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AmsSerialResetFrame) isAmsSerialResetFrame() bool {
+ return true
+}
+
func (m *_AmsSerialResetFrame) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/AmsTCPPacket.go b/plc4go/protocols/ads/readwrite/model/AmsTCPPacket.go
index e01fd65454..2eb1c29892 100644
--- a/plc4go/protocols/ads/readwrite/model/AmsTCPPacket.go
+++ b/plc4go/protocols/ads/readwrite/model/AmsTCPPacket.go
@@ -35,6 +35,12 @@ type AmsTCPPacket interface {
GetUserdata() AmsPacket
}
+// AmsTCPPacketExactly can be used when we want exactly this type and not a type which fulfills AmsTCPPacket.
+// This is useful for switch cases.
+type AmsTCPPacketExactly interface {
+ isAmsTCPPacket() bool
+}
+
// _AmsTCPPacket is the data-structure of this message
type _AmsTCPPacket struct {
Userdata AmsPacket
@@ -188,6 +194,10 @@ func (m *_AmsTCPPacket) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_AmsTCPPacket) isAmsTCPPacket() bool {
+ return true
+}
+
func (m *_AmsTCPPacket) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/ads/readwrite/model/State.go b/plc4go/protocols/ads/readwrite/model/State.go
index eed1a1c904..dbfe663149 100644
--- a/plc4go/protocols/ads/readwrite/model/State.go
+++ b/plc4go/protocols/ads/readwrite/model/State.go
@@ -51,6 +51,12 @@ type State interface {
GetBroadcast() bool
}
+// StateExactly can be used when we want exactly this type and not a type which fulfills State.
+// This is useful for switch cases.
+type StateExactly interface {
+ isState() bool
+}
+
// _State is the data-structure of this message
type _State struct {
InitCommand bool
@@ -352,6 +358,10 @@ func (m *_State) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_State) isState() bool {
+ return true
+}
+
func (m *_State) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDU.go b/plc4go/protocols/bacnetip/readwrite/model/APDU.go
index d2b2335c1c..9ee7462f04 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDU.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDU.go
@@ -34,6 +34,12 @@ type APDU interface {
GetApduType() ApduType
}
+// APDUExactly can be used when we want exactly this type and not a type which fulfills APDU.
+// This is useful for switch cases.
+type APDUExactly interface {
+ isAPDU() bool
+}
+
// _APDU is the data-structure of this message
type _APDU struct {
_APDUChildRequirements
@@ -43,10 +49,10 @@ type _APDU struct {
}
type _APDUChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetApduType() ApduType
- Serialize(writeBuffer utils.WriteBuffer) error
}
type APDUParent interface {
@@ -55,7 +61,7 @@ type APDUParent interface {
}
type APDUChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent APDU)
GetParent() *APDU
@@ -198,6 +204,10 @@ func (pm *_APDU) SerializeParent(writeBuffer utils.WriteBuffer, child APDU, seri
return nil
}
+func (m *_APDU) isAPDU() bool {
+ return true
+}
+
func (m *_APDU) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUAbort.go b/plc4go/protocols/bacnetip/readwrite/model/APDUAbort.go
index 428698e065..3e383c208c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUAbort.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUAbort.go
@@ -40,6 +40,12 @@ type APDUAbort interface {
GetAbortReason() BACnetAbortReasonTagged
}
+// APDUAbortExactly can be used when we want exactly this type and not a type which fulfills APDUAbort.
+// This is useful for switch cases.
+type APDUAbortExactly interface {
+ isAPDUAbort() bool
+}
+
// _APDUAbort is the data-structure of this message
type _APDUAbort struct {
*_APDU
@@ -261,6 +267,10 @@ func (m *_APDUAbort) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUAbort) isAPDUAbort() bool {
+ return true
+}
+
func (m *_APDUAbort) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUComplexAck.go b/plc4go/protocols/bacnetip/readwrite/model/APDUComplexAck.go
index 5426d754ef..6c720a91ee 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUComplexAck.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUComplexAck.go
@@ -55,6 +55,12 @@ type APDUComplexAck interface {
GetSegmentReduction() uint16
}
+// APDUComplexAckExactly can be used when we want exactly this type and not a type which fulfills APDUComplexAck.
+// This is useful for switch cases.
+type APDUComplexAckExactly interface {
+ isAPDUComplexAck() bool
+}
+
// _APDUComplexAck is the data-structure of this message
type _APDUComplexAck struct {
*_APDU
@@ -500,6 +506,10 @@ func (m *_APDUComplexAck) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUComplexAck) isAPDUComplexAck() bool {
+ return true
+}
+
func (m *_APDUComplexAck) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUConfirmedRequest.go b/plc4go/protocols/bacnetip/readwrite/model/APDUConfirmedRequest.go
index 688a5d9f50..9940c4bda4 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUConfirmedRequest.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUConfirmedRequest.go
@@ -61,6 +61,12 @@ type APDUConfirmedRequest interface {
GetSegmentReduction() uint16
}
+// APDUConfirmedRequestExactly can be used when we want exactly this type and not a type which fulfills APDUConfirmedRequest.
+// This is useful for switch cases.
+type APDUConfirmedRequestExactly interface {
+ isAPDUConfirmedRequest() bool
+}
+
// _APDUConfirmedRequest is the data-structure of this message
type _APDUConfirmedRequest struct {
*_APDU
@@ -600,6 +606,10 @@ func (m *_APDUConfirmedRequest) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUConfirmedRequest) isAPDUConfirmedRequest() bool {
+ return true
+}
+
func (m *_APDUConfirmedRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUError.go b/plc4go/protocols/bacnetip/readwrite/model/APDUError.go
index bdb6a00ea6..1b8231fcbf 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUError.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUError.go
@@ -40,6 +40,12 @@ type APDUError interface {
GetError() BACnetError
}
+// APDUErrorExactly can be used when we want exactly this type and not a type which fulfills APDUError.
+// This is useful for switch cases.
+type APDUErrorExactly interface {
+ isAPDUError() bool
+}
+
// _APDUError is the data-structure of this message
type _APDUError struct {
*_APDU
@@ -272,6 +278,10 @@ func (m *_APDUError) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUError) isAPDUError() bool {
+ return true
+}
+
func (m *_APDUError) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUReject.go b/plc4go/protocols/bacnetip/readwrite/model/APDUReject.go
index bce2c9056c..f269952098 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUReject.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUReject.go
@@ -38,6 +38,12 @@ type APDUReject interface {
GetRejectReason() BACnetRejectReasonTagged
}
+// APDURejectExactly can be used when we want exactly this type and not a type which fulfills APDUReject.
+// This is useful for switch cases.
+type APDURejectExactly interface {
+ isAPDUReject() bool
+}
+
// _APDUReject is the data-structure of this message
type _APDUReject struct {
*_APDU
@@ -235,6 +241,10 @@ func (m *_APDUReject) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUReject) isAPDUReject() bool {
+ return true
+}
+
func (m *_APDUReject) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUSegmentAck.go b/plc4go/protocols/bacnetip/readwrite/model/APDUSegmentAck.go
index a0a391809a..d0b43332b5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUSegmentAck.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUSegmentAck.go
@@ -44,6 +44,12 @@ type APDUSegmentAck interface {
GetProposedWindowSize() uint8
}
+// APDUSegmentAckExactly can be used when we want exactly this type and not a type which fulfills APDUSegmentAck.
+// This is useful for switch cases.
+type APDUSegmentAckExactly interface {
+ isAPDUSegmentAck() bool
+}
+
// _APDUSegmentAck is the data-structure of this message
type _APDUSegmentAck struct {
*_APDU
@@ -302,6 +308,10 @@ func (m *_APDUSegmentAck) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUSegmentAck) isAPDUSegmentAck() bool {
+ return true
+}
+
func (m *_APDUSegmentAck) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUSimpleAck.go b/plc4go/protocols/bacnetip/readwrite/model/APDUSimpleAck.go
index 537463cdf0..9df89b883b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUSimpleAck.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUSimpleAck.go
@@ -38,6 +38,12 @@ type APDUSimpleAck interface {
GetServiceChoice() uint8
}
+// APDUSimpleAckExactly can be used when we want exactly this type and not a type which fulfills APDUSimpleAck.
+// This is useful for switch cases.
+type APDUSimpleAckExactly interface {
+ isAPDUSimpleAck() bool
+}
+
// _APDUSimpleAck is the data-structure of this message
type _APDUSimpleAck struct {
*_APDU
@@ -224,6 +230,10 @@ func (m *_APDUSimpleAck) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUSimpleAck) isAPDUSimpleAck() bool {
+ return true
+}
+
func (m *_APDUSimpleAck) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUUnconfirmedRequest.go b/plc4go/protocols/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
index 03d1c44b84..1d2abd0bcd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
@@ -36,6 +36,12 @@ type APDUUnconfirmedRequest interface {
GetServiceRequest() BACnetUnconfirmedServiceRequest
}
+// APDUUnconfirmedRequestExactly can be used when we want exactly this type and not a type which fulfills APDUUnconfirmedRequest.
+// This is useful for switch cases.
+type APDUUnconfirmedRequestExactly interface {
+ isAPDUUnconfirmedRequest() bool
+}
+
// _APDUUnconfirmedRequest is the data-structure of this message
type _APDUUnconfirmedRequest struct {
*_APDU
@@ -209,6 +215,10 @@ func (m *_APDUUnconfirmedRequest) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUUnconfirmedRequest) isAPDUUnconfirmedRequest() bool {
+ return true
+}
+
func (m *_APDUUnconfirmedRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/APDUUnknown.go b/plc4go/protocols/bacnetip/readwrite/model/APDUUnknown.go
index af1ee115e6..54e64083ae 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/APDUUnknown.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/APDUUnknown.go
@@ -37,6 +37,12 @@ type APDUUnknown interface {
GetUnknownBytes() []byte
}
+// APDUUnknownExactly can be used when we want exactly this type and not a type which fulfills APDUUnknown.
+// This is useful for switch cases.
+type APDUUnknownExactly interface {
+ isAPDUUnknown() bool
+}
+
// _APDUUnknown is the data-structure of this message
type _APDUUnknown struct {
*_APDU
@@ -201,6 +207,10 @@ func (m *_APDUUnknown) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_APDUUnknown) isAPDUUnknown() bool {
+ return true
+}
+
func (m *_APDUUnknown) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAbortReasonTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAbortReasonTagged.go
index eca845c3b4..532317d10c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAbortReasonTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAbortReasonTagged.go
@@ -38,6 +38,12 @@ type BACnetAbortReasonTagged interface {
GetIsProprietary() bool
}
+// BACnetAbortReasonTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAbortReasonTagged.
+// This is useful for switch cases.
+type BACnetAbortReasonTaggedExactly interface {
+ isBACnetAbortReasonTagged() bool
+}
+
// _BACnetAbortReasonTagged is the data-structure of this message
type _BACnetAbortReasonTagged struct {
Value BACnetAbortReason
@@ -185,6 +191,10 @@ func (m *_BACnetAbortReasonTagged) Serialize(writeBuffer utils.WriteBuffer) erro
return nil
}
+func (m *_BACnetAbortReasonTagged) isBACnetAbortReasonTagged() bool {
+ return true
+}
+
func (m *_BACnetAbortReasonTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessAuthenticationFactorDisableTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessAuthenticationFactorDisableTagged.go
index 98a3156222..6b3d3d3637 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessAuthenticationFactorDisableTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessAuthenticationFactorDisableTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessAuthenticationFactorDisableTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessAuthenticationFactorDisableTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessAuthenticationFactorDisableTagged.
+// This is useful for switch cases.
+type BACnetAccessAuthenticationFactorDisableTaggedExactly interface {
+ isBACnetAccessAuthenticationFactorDisableTagged() bool
+}
+
// _BACnetAccessAuthenticationFactorDisableTagged is the data-structure of this message
type _BACnetAccessAuthenticationFactorDisableTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessAuthenticationFactorDisableTagged) Serialize(writeBuffer u
return nil
}
+func (m *_BACnetAccessAuthenticationFactorDisableTagged) isBACnetAccessAuthenticationFactorDisableTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessAuthenticationFactorDisableTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableReasonTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableReasonTagged.go
index bb77435405..1a497bad87 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableReasonTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableReasonTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessCredentialDisableReasonTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessCredentialDisableReasonTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessCredentialDisableReasonTagged.
+// This is useful for switch cases.
+type BACnetAccessCredentialDisableReasonTaggedExactly interface {
+ isBACnetAccessCredentialDisableReasonTagged() bool
+}
+
// _BACnetAccessCredentialDisableReasonTagged is the data-structure of this message
type _BACnetAccessCredentialDisableReasonTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessCredentialDisableReasonTagged) Serialize(writeBuffer utils
return nil
}
+func (m *_BACnetAccessCredentialDisableReasonTagged) isBACnetAccessCredentialDisableReasonTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessCredentialDisableReasonTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableTagged.go
index c9c93221d1..f7ebe5fc94 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessCredentialDisableTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessCredentialDisableTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessCredentialDisableTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessCredentialDisableTagged.
+// This is useful for switch cases.
+type BACnetAccessCredentialDisableTaggedExactly interface {
+ isBACnetAccessCredentialDisableTagged() bool
+}
+
// _BACnetAccessCredentialDisableTagged is the data-structure of this message
type _BACnetAccessCredentialDisableTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessCredentialDisableTagged) Serialize(writeBuffer utils.Write
return nil
}
+func (m *_BACnetAccessCredentialDisableTagged) isBACnetAccessCredentialDisableTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessCredentialDisableTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessEventTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessEventTagged.go
index fb020fcd94..f2b5415759 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessEventTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessEventTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessEventTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessEventTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessEventTagged.
+// This is useful for switch cases.
+type BACnetAccessEventTaggedExactly interface {
+ isBACnetAccessEventTagged() bool
+}
+
// _BACnetAccessEventTagged is the data-structure of this message
type _BACnetAccessEventTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessEventTagged) Serialize(writeBuffer utils.WriteBuffer) erro
return nil
}
+func (m *_BACnetAccessEventTagged) isBACnetAccessEventTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessEventTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessPassbackModeTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessPassbackModeTagged.go
index dc5aa552dc..9a91ad19b2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessPassbackModeTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessPassbackModeTagged.go
@@ -36,6 +36,12 @@ type BACnetAccessPassbackModeTagged interface {
GetValue() BACnetAccessPassbackMode
}
+// BACnetAccessPassbackModeTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessPassbackModeTagged.
+// This is useful for switch cases.
+type BACnetAccessPassbackModeTaggedExactly interface {
+ isBACnetAccessPassbackModeTagged() bool
+}
+
// _BACnetAccessPassbackModeTagged is the data-structure of this message
type _BACnetAccessPassbackModeTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAccessPassbackModeTagged) Serialize(writeBuffer utils.WriteBuffe
return nil
}
+func (m *_BACnetAccessPassbackModeTagged) isBACnetAccessPassbackModeTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessPassbackModeTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go
index f5ebf3d18a..3765b807c8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go
@@ -44,6 +44,12 @@ type BACnetAccessRule interface {
GetEnable() BACnetContextTagBoolean
}
+// BACnetAccessRuleExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessRule.
+// This is useful for switch cases.
+type BACnetAccessRuleExactly interface {
+ isBACnetAccessRule() bool
+}
+
// _BACnetAccessRule is the data-structure of this message
type _BACnetAccessRule struct {
TimeRangeSpecifier BACnetAccessRuleTimeRangeSpecifierTagged
@@ -317,6 +323,10 @@ func (m *_BACnetAccessRule) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetAccessRule) isBACnetAccessRule() bool {
+ return true
+}
+
func (m *_BACnetAccessRule) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go
index d72b8ed29d..6087f206c7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go
@@ -36,6 +36,12 @@ type BACnetAccessRuleLocationSpecifierTagged interface {
GetValue() BACnetAccessRuleLocationSpecifier
}
+// BACnetAccessRuleLocationSpecifierTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessRuleLocationSpecifierTagged.
+// This is useful for switch cases.
+type BACnetAccessRuleLocationSpecifierTaggedExactly interface {
+ isBACnetAccessRuleLocationSpecifierTagged() bool
+}
+
// _BACnetAccessRuleLocationSpecifierTagged is the data-structure of this message
type _BACnetAccessRuleLocationSpecifierTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAccessRuleLocationSpecifierTagged) Serialize(writeBuffer utils.W
return nil
}
+func (m *_BACnetAccessRuleLocationSpecifierTagged) isBACnetAccessRuleLocationSpecifierTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessRuleLocationSpecifierTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go
index 46de34a7a3..eaf9201372 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go
@@ -36,6 +36,12 @@ type BACnetAccessRuleTimeRangeSpecifierTagged interface {
GetValue() BACnetAccessRuleTimeRangeSpecifier
}
+// BACnetAccessRuleTimeRangeSpecifierTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessRuleTimeRangeSpecifierTagged.
+// This is useful for switch cases.
+type BACnetAccessRuleTimeRangeSpecifierTaggedExactly interface {
+ isBACnetAccessRuleTimeRangeSpecifierTagged() bool
+}
+
// _BACnetAccessRuleTimeRangeSpecifierTagged is the data-structure of this message
type _BACnetAccessRuleTimeRangeSpecifierTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAccessRuleTimeRangeSpecifierTagged) Serialize(writeBuffer utils.
return nil
}
+func (m *_BACnetAccessRuleTimeRangeSpecifierTagged) isBACnetAccessRuleTimeRangeSpecifierTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessRuleTimeRangeSpecifierTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessThreatLevel.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessThreatLevel.go
index 378c9565c9..a21d4905ea 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessThreatLevel.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessThreatLevel.go
@@ -34,6 +34,12 @@ type BACnetAccessThreatLevel interface {
GetThreatLevel() BACnetApplicationTagUnsignedInteger
}
+// BACnetAccessThreatLevelExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessThreatLevel.
+// This is useful for switch cases.
+type BACnetAccessThreatLevelExactly interface {
+ isBACnetAccessThreatLevel() bool
+}
+
// _BACnetAccessThreatLevel is the data-structure of this message
type _BACnetAccessThreatLevel struct {
ThreatLevel BACnetApplicationTagUnsignedInteger
@@ -145,6 +151,10 @@ func (m *_BACnetAccessThreatLevel) Serialize(writeBuffer utils.WriteBuffer) erro
return nil
}
+func (m *_BACnetAccessThreatLevel) isBACnetAccessThreatLevel() bool {
+ return true
+}
+
func (m *_BACnetAccessThreatLevel) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessUserTypeTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessUserTypeTagged.go
index 800c7a52d4..9c8e7d6d34 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessUserTypeTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessUserTypeTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessUserTypeTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessUserTypeTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessUserTypeTagged.
+// This is useful for switch cases.
+type BACnetAccessUserTypeTaggedExactly interface {
+ isBACnetAccessUserTypeTagged() bool
+}
+
// _BACnetAccessUserTypeTagged is the data-structure of this message
type _BACnetAccessUserTypeTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessUserTypeTagged) Serialize(writeBuffer utils.WriteBuffer) e
return nil
}
+func (m *_BACnetAccessUserTypeTagged) isBACnetAccessUserTypeTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessUserTypeTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessZoneOccupancyStateTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessZoneOccupancyStateTagged.go
index 6d74d09f08..2bb34680c6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessZoneOccupancyStateTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessZoneOccupancyStateTagged.go
@@ -40,6 +40,12 @@ type BACnetAccessZoneOccupancyStateTagged interface {
GetIsProprietary() bool
}
+// BACnetAccessZoneOccupancyStateTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccessZoneOccupancyStateTagged.
+// This is useful for switch cases.
+type BACnetAccessZoneOccupancyStateTaggedExactly interface {
+ isBACnetAccessZoneOccupancyStateTagged() bool
+}
+
// _BACnetAccessZoneOccupancyStateTagged is the data-structure of this message
type _BACnetAccessZoneOccupancyStateTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAccessZoneOccupancyStateTagged) Serialize(writeBuffer utils.Writ
return nil
}
+func (m *_BACnetAccessZoneOccupancyStateTagged) isBACnetAccessZoneOccupancyStateTagged() bool {
+ return true
+}
+
func (m *_BACnetAccessZoneOccupancyStateTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecord.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecord.go
index d7b4cc1a09..e5668d80aa 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecord.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecord.go
@@ -40,6 +40,12 @@ type BACnetAccumulatorRecord interface {
GetAccumulatorStatus() BACnetAccumulatorRecordAccumulatorStatusTagged
}
+// BACnetAccumulatorRecordExactly can be used when we want exactly this type and not a type which fulfills BACnetAccumulatorRecord.
+// This is useful for switch cases.
+type BACnetAccumulatorRecordExactly interface {
+ isBACnetAccumulatorRecord() bool
+}
+
// _BACnetAccumulatorRecord is the data-structure of this message
type _BACnetAccumulatorRecord struct {
Timestamp BACnetDateTimeEnclosed
@@ -250,6 +256,10 @@ func (m *_BACnetAccumulatorRecord) Serialize(writeBuffer utils.WriteBuffer) erro
return nil
}
+func (m *_BACnetAccumulatorRecord) isBACnetAccumulatorRecord() bool {
+ return true
+}
+
func (m *_BACnetAccumulatorRecord) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecordAccumulatorStatusTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecordAccumulatorStatusTagged.go
index 38e7523188..7475e1a460 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecordAccumulatorStatusTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccumulatorRecordAccumulatorStatusTagged.go
@@ -36,6 +36,12 @@ type BACnetAccumulatorRecordAccumulatorStatusTagged interface {
GetValue() BACnetAccumulatorRecordAccumulatorStatus
}
+// BACnetAccumulatorRecordAccumulatorStatusTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAccumulatorRecordAccumulatorStatusTagged.
+// This is useful for switch cases.
+type BACnetAccumulatorRecordAccumulatorStatusTaggedExactly interface {
+ isBACnetAccumulatorRecordAccumulatorStatusTagged() bool
+}
+
// _BACnetAccumulatorRecordAccumulatorStatusTagged is the data-structure of this message
type _BACnetAccumulatorRecordAccumulatorStatusTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAccumulatorRecordAccumulatorStatusTagged) Serialize(writeBuffer
return nil
}
+func (m *_BACnetAccumulatorRecordAccumulatorStatusTagged) isBACnetAccumulatorRecordAccumulatorStatusTagged() bool {
+ return true
+}
+
func (m *_BACnetAccumulatorRecordAccumulatorStatusTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionCommand.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionCommand.go
index 913f11d810..9c9c3ffbb1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionCommand.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionCommand.go
@@ -52,6 +52,12 @@ type BACnetActionCommand interface {
GetWriteSuccessful() BACnetContextTagBoolean
}
+// BACnetActionCommandExactly can be used when we want exactly this type and not a type which fulfills BACnetActionCommand.
+// This is useful for switch cases.
+type BACnetActionCommandExactly interface {
+ isBACnetActionCommand() bool
+}
+
// _BACnetActionCommand is the data-structure of this message
type _BACnetActionCommand struct {
DeviceIdentifier BACnetContextTagObjectIdentifier
@@ -502,6 +508,10 @@ func (m *_BACnetActionCommand) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetActionCommand) isBACnetActionCommand() bool {
+ return true
+}
+
func (m *_BACnetActionCommand) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionList.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionList.go
index 5885b45a47..e016ae531f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionList.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionList.go
@@ -38,6 +38,12 @@ type BACnetActionList interface {
GetInnerClosingTag() BACnetClosingTag
}
+// BACnetActionListExactly can be used when we want exactly this type and not a type which fulfills BACnetActionList.
+// This is useful for switch cases.
+type BACnetActionListExactly interface {
+ isBACnetActionList() bool
+}
+
// _BACnetActionList is the data-structure of this message
type _BACnetActionList struct {
InnerOpeningTag BACnetOpeningTag
@@ -230,6 +236,10 @@ func (m *_BACnetActionList) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetActionList) isBACnetActionList() bool {
+ return true
+}
+
func (m *_BACnetActionList) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionTagged.go
index 090b137d20..ca007eb895 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetActionTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetActionTagged.go
@@ -36,6 +36,12 @@ type BACnetActionTagged interface {
GetValue() BACnetAction
}
+// BACnetActionTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetActionTagged.
+// This is useful for switch cases.
+type BACnetActionTaggedExactly interface {
+ isBACnetActionTagged() bool
+}
+
// _BACnetActionTagged is the data-structure of this message
type _BACnetActionTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetActionTagged) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetActionTagged) isBACnetActionTagged() bool {
+ return true
+}
+
func (m *_BACnetActionTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddress.go
index ec399a8a81..00b0e0d864 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddress.go
@@ -42,6 +42,12 @@ type BACnetAddress interface {
GetIsBroadcast() bool
}
+// BACnetAddressExactly can be used when we want exactly this type and not a type which fulfills BACnetAddress.
+// This is useful for switch cases.
+type BACnetAddressExactly interface {
+ isBACnetAddress() bool
+}
+
// _BACnetAddress is the data-structure of this message
type _BACnetAddress struct {
NetworkNumber BACnetApplicationTagUnsignedInteger
@@ -240,6 +246,10 @@ func (m *_BACnetAddress) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetAddress) isBACnetAddress() bool {
+ return true
+}
+
func (m *_BACnetAddress) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go
index 1cf2002ffa..c0e580b4af 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go
@@ -36,6 +36,12 @@ type BACnetAddressBinding interface {
GetDeviceAddress() BACnetAddress
}
+// BACnetAddressBindingExactly can be used when we want exactly this type and not a type which fulfills BACnetAddressBinding.
+// This is useful for switch cases.
+type BACnetAddressBindingExactly interface {
+ isBACnetAddressBinding() bool
+}
+
// _BACnetAddressBinding is the data-structure of this message
type _BACnetAddressBinding struct {
DeviceIdentifier BACnetApplicationTagObjectIdentifier
@@ -180,6 +186,10 @@ func (m *_BACnetAddressBinding) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetAddressBinding) isBACnetAddressBinding() bool {
+ return true
+}
+
func (m *_BACnetAddressBinding) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressEnclosed.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressEnclosed.go
index 3d3b5b8ee8..ee4818425e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressEnclosed.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressEnclosed.go
@@ -38,6 +38,12 @@ type BACnetAddressEnclosed interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetAddressEnclosedExactly can be used when we want exactly this type and not a type which fulfills BACnetAddressEnclosed.
+// This is useful for switch cases.
+type BACnetAddressEnclosedExactly interface {
+ isBACnetAddressEnclosed() bool
+}
+
// _BACnetAddressEnclosed is the data-structure of this message
type _BACnetAddressEnclosed struct {
OpeningTag BACnetOpeningTag
@@ -218,6 +224,10 @@ func (m *_BACnetAddressEnclosed) Serialize(writeBuffer utils.WriteBuffer) error
return nil
}
+func (m *_BACnetAddressEnclosed) isBACnetAddressEnclosed() bool {
+ return true
+}
+
func (m *_BACnetAddressEnclosed) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTag.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTag.go
index 75f1f6c960..dcbb883d63 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTag.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTag.go
@@ -38,6 +38,12 @@ type BACnetApplicationTag interface {
GetActualLength() uint32
}
+// BACnetApplicationTagExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTag.
+// This is useful for switch cases.
+type BACnetApplicationTagExactly interface {
+ isBACnetApplicationTag() bool
+}
+
// _BACnetApplicationTag is the data-structure of this message
type _BACnetApplicationTag struct {
_BACnetApplicationTagChildRequirements
@@ -45,9 +51,9 @@ type _BACnetApplicationTag struct {
}
type _BACnetApplicationTagChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetApplicationTagParent interface {
@@ -56,7 +62,7 @@ type BACnetApplicationTagParent interface {
}
type BACnetApplicationTagChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetApplicationTag, header BACnetTagHeader)
GetParent() *BACnetApplicationTag
@@ -264,6 +270,10 @@ func (pm *_BACnetApplicationTag) SerializeParent(writeBuffer utils.WriteBuffer,
return nil
}
+func (m *_BACnetApplicationTag) isBACnetApplicationTag() bool {
+ return true
+}
+
func (m *_BACnetApplicationTag) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBitString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
index deb6d88d5b..448df39788 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
@@ -35,6 +35,12 @@ type BACnetApplicationTagBitString interface {
GetPayload() BACnetTagPayloadBitString
}
+// BACnetApplicationTagBitStringExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagBitString.
+// This is useful for switch cases.
+type BACnetApplicationTagBitStringExactly interface {
+ isBACnetApplicationTagBitString() bool
+}
+
// _BACnetApplicationTagBitString is the data-structure of this message
type _BACnetApplicationTagBitString struct {
*_BACnetApplicationTag
@@ -178,6 +184,10 @@ func (m *_BACnetApplicationTagBitString) Serialize(writeBuffer utils.WriteBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagBitString) isBACnetApplicationTagBitString() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagBitString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
index 9eac9212e3..70a4ae833e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagBoolean interface {
GetActualValue() bool
}
+// BACnetApplicationTagBooleanExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagBoolean.
+// This is useful for switch cases.
+type BACnetApplicationTagBooleanExactly interface {
+ isBACnetApplicationTagBoolean() bool
+}
+
// _BACnetApplicationTagBoolean is the data-structure of this message
type _BACnetApplicationTagBoolean struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagBoolean) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagBoolean) isBACnetApplicationTagBoolean() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagBoolean) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
index 768f874da8..021ec2fa98 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagCharacterString interface {
GetValue() string
}
+// BACnetApplicationTagCharacterStringExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagCharacterString.
+// This is useful for switch cases.
+type BACnetApplicationTagCharacterStringExactly interface {
+ isBACnetApplicationTagCharacterString() bool
+}
+
// _BACnetApplicationTagCharacterString is the data-structure of this message
type _BACnetApplicationTagCharacterString struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagCharacterString) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagCharacterString) isBACnetApplicationTagCharacterString() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagCharacterString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDate.go
index 78026f4357..4eeb3a7c3b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDate.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDate.go
@@ -35,6 +35,12 @@ type BACnetApplicationTagDate interface {
GetPayload() BACnetTagPayloadDate
}
+// BACnetApplicationTagDateExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagDate.
+// This is useful for switch cases.
+type BACnetApplicationTagDateExactly interface {
+ isBACnetApplicationTagDate() bool
+}
+
// _BACnetApplicationTagDate is the data-structure of this message
type _BACnetApplicationTagDate struct {
*_BACnetApplicationTag
@@ -178,6 +184,10 @@ func (m *_BACnetApplicationTagDate) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagDate) isBACnetApplicationTagDate() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagDate) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDouble.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
index 1865548b9b..a7201e39a1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagDouble interface {
GetActualValue() float64
}
+// BACnetApplicationTagDoubleExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagDouble.
+// This is useful for switch cases.
+type BACnetApplicationTagDoubleExactly interface {
+ isBACnetApplicationTagDouble() bool
+}
+
// _BACnetApplicationTagDouble is the data-structure of this message
type _BACnetApplicationTagDouble struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagDouble) Serialize(writeBuffer utils.WriteBuffer) e
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagDouble) isBACnetApplicationTagDouble() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagDouble) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
index dfa0b33826..88d34b4405 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagEnumerated interface {
GetActualValue() uint32
}
+// BACnetApplicationTagEnumeratedExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagEnumerated.
+// This is useful for switch cases.
+type BACnetApplicationTagEnumeratedExactly interface {
+ isBACnetApplicationTagEnumerated() bool
+}
+
// _BACnetApplicationTagEnumerated is the data-structure of this message
type _BACnetApplicationTagEnumerated struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagEnumerated) Serialize(writeBuffer utils.WriteBuffe
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagEnumerated) isBACnetApplicationTagEnumerated() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagEnumerated) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagNull.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagNull.go
index a2ea04c31f..119ba5332e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagNull.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagNull.go
@@ -33,6 +33,12 @@ type BACnetApplicationTagNull interface {
BACnetApplicationTag
}
+// BACnetApplicationTagNullExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagNull.
+// This is useful for switch cases.
+type BACnetApplicationTagNullExactly interface {
+ isBACnetApplicationTagNull() bool
+}
+
// _BACnetApplicationTagNull is the data-structure of this message
type _BACnetApplicationTagNull struct {
*_BACnetApplicationTag
@@ -131,6 +137,10 @@ func (m *_BACnetApplicationTagNull) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagNull) isBACnetApplicationTagNull() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagNull) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
index 8bf0fbdd62..d8765051ea 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
@@ -39,6 +39,12 @@ type BACnetApplicationTagObjectIdentifier interface {
GetInstanceNumber() uint32
}
+// BACnetApplicationTagObjectIdentifierExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagObjectIdentifier.
+// This is useful for switch cases.
+type BACnetApplicationTagObjectIdentifierExactly interface {
+ isBACnetApplicationTagObjectIdentifier() bool
+}
+
// _BACnetApplicationTagObjectIdentifier is the data-structure of this message
type _BACnetApplicationTagObjectIdentifier struct {
*_BACnetApplicationTag
@@ -221,6 +227,10 @@ func (m *_BACnetApplicationTagObjectIdentifier) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagObjectIdentifier) isBACnetApplicationTagObjectIdentifier() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagObjectIdentifier) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
index 614d8293ed..60859248d0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
@@ -35,6 +35,12 @@ type BACnetApplicationTagOctetString interface {
GetPayload() BACnetTagPayloadOctetString
}
+// BACnetApplicationTagOctetStringExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagOctetString.
+// This is useful for switch cases.
+type BACnetApplicationTagOctetStringExactly interface {
+ isBACnetApplicationTagOctetString() bool
+}
+
// _BACnetApplicationTagOctetString is the data-structure of this message
type _BACnetApplicationTagOctetString struct {
*_BACnetApplicationTag
@@ -178,6 +184,10 @@ func (m *_BACnetApplicationTagOctetString) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagOctetString) isBACnetApplicationTagOctetString() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagOctetString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagReal.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagReal.go
index 8f533817a2..a22d1031b2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagReal.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagReal.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagReal interface {
GetActualValue() float32
}
+// BACnetApplicationTagRealExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagReal.
+// This is useful for switch cases.
+type BACnetApplicationTagRealExactly interface {
+ isBACnetApplicationTagReal() bool
+}
+
// _BACnetApplicationTagReal is the data-structure of this message
type _BACnetApplicationTagReal struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagReal) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagReal) isBACnetApplicationTagReal() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagReal) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
index 4591ad1de7..39258f7ec6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagSignedInteger interface {
GetActualValue() uint64
}
+// BACnetApplicationTagSignedIntegerExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagSignedInteger.
+// This is useful for switch cases.
+type BACnetApplicationTagSignedIntegerExactly interface {
+ isBACnetApplicationTagSignedInteger() bool
+}
+
// _BACnetApplicationTagSignedInteger is the data-structure of this message
type _BACnetApplicationTagSignedInteger struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagSignedInteger) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagSignedInteger) isBACnetApplicationTagSignedInteger() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagSignedInteger) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagTime.go
index a693f03f54..73d03305ed 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagTime.go
@@ -35,6 +35,12 @@ type BACnetApplicationTagTime interface {
GetPayload() BACnetTagPayloadTime
}
+// BACnetApplicationTagTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagTime.
+// This is useful for switch cases.
+type BACnetApplicationTagTimeExactly interface {
+ isBACnetApplicationTagTime() bool
+}
+
// _BACnetApplicationTagTime is the data-structure of this message
type _BACnetApplicationTagTime struct {
*_BACnetApplicationTag
@@ -178,6 +184,10 @@ func (m *_BACnetApplicationTagTime) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagTime) isBACnetApplicationTagTime() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
index 741a6440ce..763e04a471 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
@@ -37,6 +37,12 @@ type BACnetApplicationTagUnsignedInteger interface {
GetActualValue() uint64
}
+// BACnetApplicationTagUnsignedIntegerExactly can be used when we want exactly this type and not a type which fulfills BACnetApplicationTagUnsignedInteger.
+// This is useful for switch cases.
+type BACnetApplicationTagUnsignedIntegerExactly interface {
+ isBACnetApplicationTagUnsignedInteger() bool
+}
+
// _BACnetApplicationTagUnsignedInteger is the data-structure of this message
type _BACnetApplicationTagUnsignedInteger struct {
*_BACnetApplicationTag
@@ -204,6 +210,10 @@ func (m *_BACnetApplicationTagUnsignedInteger) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetApplicationTagUnsignedInteger) isBACnetApplicationTagUnsignedInteger() bool {
+ return true
+}
+
func (m *_BACnetApplicationTagUnsignedInteger) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedAccessRights.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedAccessRights.go
index 1724485ce0..a864f86119 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedAccessRights.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedAccessRights.go
@@ -36,6 +36,12 @@ type BACnetAssignedAccessRights interface {
GetEnable() BACnetContextTagBoolean
}
+// BACnetAssignedAccessRightsExactly can be used when we want exactly this type and not a type which fulfills BACnetAssignedAccessRights.
+// This is useful for switch cases.
+type BACnetAssignedAccessRightsExactly interface {
+ isBACnetAssignedAccessRights() bool
+}
+
// _BACnetAssignedAccessRights is the data-structure of this message
type _BACnetAssignedAccessRights struct {
AssignedAccessRights BACnetDeviceObjectReferenceEnclosed
@@ -180,6 +186,10 @@ func (m *_BACnetAssignedAccessRights) Serialize(writeBuffer utils.WriteBuffer) e
return nil
}
+func (m *_BACnetAssignedAccessRights) isBACnetAssignedAccessRights() bool {
+ return true
+}
+
func (m *_BACnetAssignedAccessRights) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCalls.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCalls.go
index 3bf6264f88..1915924a6a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCalls.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCalls.go
@@ -34,6 +34,12 @@ type BACnetAssignedLandingCalls interface {
GetLandingCalls() BACnetAssignedLandingCallsLandingCallsList
}
+// BACnetAssignedLandingCallsExactly can be used when we want exactly this type and not a type which fulfills BACnetAssignedLandingCalls.
+// This is useful for switch cases.
+type BACnetAssignedLandingCallsExactly interface {
+ isBACnetAssignedLandingCalls() bool
+}
+
// _BACnetAssignedLandingCalls is the data-structure of this message
type _BACnetAssignedLandingCalls struct {
LandingCalls BACnetAssignedLandingCallsLandingCallsList
@@ -145,6 +151,10 @@ func (m *_BACnetAssignedLandingCalls) Serialize(writeBuffer utils.WriteBuffer) e
return nil
}
+func (m *_BACnetAssignedLandingCalls) isBACnetAssignedLandingCalls() bool {
+ return true
+}
+
func (m *_BACnetAssignedLandingCalls) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsList.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsList.go
index 2732725c3f..380b876c8d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsList.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsList.go
@@ -38,6 +38,12 @@ type BACnetAssignedLandingCallsLandingCallsList interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetAssignedLandingCallsLandingCallsListExactly can be used when we want exactly this type and not a type which fulfills BACnetAssignedLandingCallsLandingCallsList.
+// This is useful for switch cases.
+type BACnetAssignedLandingCallsLandingCallsListExactly interface {
+ isBACnetAssignedLandingCallsLandingCallsList() bool
+}
+
// _BACnetAssignedLandingCallsLandingCallsList is the data-structure of this message
type _BACnetAssignedLandingCallsLandingCallsList struct {
OpeningTag BACnetOpeningTag
@@ -233,6 +239,10 @@ func (m *_BACnetAssignedLandingCallsLandingCallsList) Serialize(writeBuffer util
return nil
}
+func (m *_BACnetAssignedLandingCallsLandingCallsList) isBACnetAssignedLandingCallsLandingCallsList() bool {
+ return true
+}
+
func (m *_BACnetAssignedLandingCallsLandingCallsList) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsListEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsListEntry.go
index a86da7fb1f..17b4795e22 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsListEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAssignedLandingCallsLandingCallsListEntry.go
@@ -36,6 +36,12 @@ type BACnetAssignedLandingCallsLandingCallsListEntry interface {
GetDirection() BACnetLiftCarDirectionTagged
}
+// BACnetAssignedLandingCallsLandingCallsListEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetAssignedLandingCallsLandingCallsListEntry.
+// This is useful for switch cases.
+type BACnetAssignedLandingCallsLandingCallsListEntryExactly interface {
+ isBACnetAssignedLandingCallsLandingCallsListEntry() bool
+}
+
// _BACnetAssignedLandingCallsLandingCallsListEntry is the data-structure of this message
type _BACnetAssignedLandingCallsLandingCallsListEntry struct {
FloorNumber BACnetContextTagUnsignedInteger
@@ -180,6 +186,10 @@ func (m *_BACnetAssignedLandingCallsLandingCallsListEntry) Serialize(writeBuffer
return nil
}
+func (m *_BACnetAssignedLandingCallsLandingCallsListEntry) isBACnetAssignedLandingCallsLandingCallsListEntry() bool {
+ return true
+}
+
func (m *_BACnetAssignedLandingCallsLandingCallsListEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactor.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactor.go
index a274648bdd..161d075170 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactor.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactor.go
@@ -38,6 +38,12 @@ type BACnetAuthenticationFactor interface {
GetValue() BACnetContextTagOctetString
}
+// BACnetAuthenticationFactorExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationFactor.
+// This is useful for switch cases.
+type BACnetAuthenticationFactorExactly interface {
+ isBACnetAuthenticationFactor() bool
+}
+
// _BACnetAuthenticationFactor is the data-structure of this message
type _BACnetAuthenticationFactor struct {
FormatType BACnetAuthenticationFactorTypeTagged
@@ -215,6 +221,10 @@ func (m *_BACnetAuthenticationFactor) Serialize(writeBuffer utils.WriteBuffer) e
return nil
}
+func (m *_BACnetAuthenticationFactor) isBACnetAuthenticationFactor() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationFactor) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorEnclosed.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorEnclosed.go
index af3700a6f3..1550d7da9d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorEnclosed.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorEnclosed.go
@@ -38,6 +38,12 @@ type BACnetAuthenticationFactorEnclosed interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetAuthenticationFactorEnclosedExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationFactorEnclosed.
+// This is useful for switch cases.
+type BACnetAuthenticationFactorEnclosedExactly interface {
+ isBACnetAuthenticationFactorEnclosed() bool
+}
+
// _BACnetAuthenticationFactorEnclosed is the data-structure of this message
type _BACnetAuthenticationFactorEnclosed struct {
OpeningTag BACnetOpeningTag
@@ -218,6 +224,10 @@ func (m *_BACnetAuthenticationFactorEnclosed) Serialize(writeBuffer utils.WriteB
return nil
}
+func (m *_BACnetAuthenticationFactorEnclosed) isBACnetAuthenticationFactorEnclosed() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationFactorEnclosed) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorFormat.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorFormat.go
index fd7c688321..79955c836a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorFormat.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorFormat.go
@@ -40,6 +40,12 @@ type BACnetAuthenticationFactorFormat interface {
GetVendorFormat() BACnetContextTagUnsignedInteger
}
+// BACnetAuthenticationFactorFormatExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationFactorFormat.
+// This is useful for switch cases.
+type BACnetAuthenticationFactorFormatExactly interface {
+ isBACnetAuthenticationFactorFormat() bool
+}
+
// _BACnetAuthenticationFactorFormat is the data-structure of this message
type _BACnetAuthenticationFactorFormat struct {
FormatType BACnetAuthenticationFactorTypeTagged
@@ -247,6 +253,10 @@ func (m *_BACnetAuthenticationFactorFormat) Serialize(writeBuffer utils.WriteBuf
return nil
}
+func (m *_BACnetAuthenticationFactorFormat) isBACnetAuthenticationFactorFormat() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationFactorFormat) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorTypeTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorTypeTagged.go
index 71656813cf..c83831b45c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorTypeTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationFactorTypeTagged.go
@@ -36,6 +36,12 @@ type BACnetAuthenticationFactorTypeTagged interface {
GetValue() BACnetAuthenticationFactorType
}
+// BACnetAuthenticationFactorTypeTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationFactorTypeTagged.
+// This is useful for switch cases.
+type BACnetAuthenticationFactorTypeTaggedExactly interface {
+ isBACnetAuthenticationFactorTypeTagged() bool
+}
+
// _BACnetAuthenticationFactorTypeTagged is the data-structure of this message
type _BACnetAuthenticationFactorTypeTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAuthenticationFactorTypeTagged) Serialize(writeBuffer utils.Writ
return nil
}
+func (m *_BACnetAuthenticationFactorTypeTagged) isBACnetAuthenticationFactorTypeTagged() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationFactorTypeTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicy.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicy.go
index c6971594eb..a519b320c7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicy.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicy.go
@@ -38,6 +38,12 @@ type BACnetAuthenticationPolicy interface {
GetTimeout() BACnetContextTagUnsignedInteger
}
+// BACnetAuthenticationPolicyExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationPolicy.
+// This is useful for switch cases.
+type BACnetAuthenticationPolicyExactly interface {
+ isBACnetAuthenticationPolicy() bool
+}
+
// _BACnetAuthenticationPolicy is the data-structure of this message
type _BACnetAuthenticationPolicy struct {
Policy BACnetAuthenticationPolicyList
@@ -215,6 +221,10 @@ func (m *_BACnetAuthenticationPolicy) Serialize(writeBuffer utils.WriteBuffer) e
return nil
}
+func (m *_BACnetAuthenticationPolicy) isBACnetAuthenticationPolicy() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationPolicy) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyList.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyList.go
index 2a8481cf53..62c4d23327 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyList.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyList.go
@@ -38,6 +38,12 @@ type BACnetAuthenticationPolicyList interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetAuthenticationPolicyListExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationPolicyList.
+// This is useful for switch cases.
+type BACnetAuthenticationPolicyListExactly interface {
+ isBACnetAuthenticationPolicyList() bool
+}
+
// _BACnetAuthenticationPolicyList is the data-structure of this message
type _BACnetAuthenticationPolicyList struct {
OpeningTag BACnetOpeningTag
@@ -233,6 +239,10 @@ func (m *_BACnetAuthenticationPolicyList) Serialize(writeBuffer utils.WriteBuffe
return nil
}
+func (m *_BACnetAuthenticationPolicyList) isBACnetAuthenticationPolicyList() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationPolicyList) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyListEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyListEntry.go
index 340023752a..4266b105f6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyListEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationPolicyListEntry.go
@@ -36,6 +36,12 @@ type BACnetAuthenticationPolicyListEntry interface {
GetIndex() BACnetContextTagUnsignedInteger
}
+// BACnetAuthenticationPolicyListEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationPolicyListEntry.
+// This is useful for switch cases.
+type BACnetAuthenticationPolicyListEntryExactly interface {
+ isBACnetAuthenticationPolicyListEntry() bool
+}
+
// _BACnetAuthenticationPolicyListEntry is the data-structure of this message
type _BACnetAuthenticationPolicyListEntry struct {
CredentialDataInput BACnetDeviceObjectReferenceEnclosed
@@ -180,6 +186,10 @@ func (m *_BACnetAuthenticationPolicyListEntry) Serialize(writeBuffer utils.Write
return nil
}
+func (m *_BACnetAuthenticationPolicyListEntry) isBACnetAuthenticationPolicyListEntry() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationPolicyListEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationStatusTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationStatusTagged.go
index 1ec9ea74e0..db622b8f17 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationStatusTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthenticationStatusTagged.go
@@ -36,6 +36,12 @@ type BACnetAuthenticationStatusTagged interface {
GetValue() BACnetAuthenticationStatus
}
+// BACnetAuthenticationStatusTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthenticationStatusTagged.
+// This is useful for switch cases.
+type BACnetAuthenticationStatusTaggedExactly interface {
+ isBACnetAuthenticationStatusTagged() bool
+}
+
// _BACnetAuthenticationStatusTagged is the data-structure of this message
type _BACnetAuthenticationStatusTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetAuthenticationStatusTagged) Serialize(writeBuffer utils.WriteBuf
return nil
}
+func (m *_BACnetAuthenticationStatusTagged) isBACnetAuthenticationStatusTagged() bool {
+ return true
+}
+
func (m *_BACnetAuthenticationStatusTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationExemptionTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationExemptionTagged.go
index a470d3bd46..eb0fa8c931 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationExemptionTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationExemptionTagged.go
@@ -40,6 +40,12 @@ type BACnetAuthorizationExemptionTagged interface {
GetIsProprietary() bool
}
+// BACnetAuthorizationExemptionTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthorizationExemptionTagged.
+// This is useful for switch cases.
+type BACnetAuthorizationExemptionTaggedExactly interface {
+ isBACnetAuthorizationExemptionTagged() bool
+}
+
// _BACnetAuthorizationExemptionTagged is the data-structure of this message
type _BACnetAuthorizationExemptionTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAuthorizationExemptionTagged) Serialize(writeBuffer utils.WriteB
return nil
}
+func (m *_BACnetAuthorizationExemptionTagged) isBACnetAuthorizationExemptionTagged() bool {
+ return true
+}
+
func (m *_BACnetAuthorizationExemptionTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationModeTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationModeTagged.go
index 836cc2536e..2602c89709 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationModeTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAuthorizationModeTagged.go
@@ -40,6 +40,12 @@ type BACnetAuthorizationModeTagged interface {
GetIsProprietary() bool
}
+// BACnetAuthorizationModeTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetAuthorizationModeTagged.
+// This is useful for switch cases.
+type BACnetAuthorizationModeTaggedExactly interface {
+ isBACnetAuthorizationModeTagged() bool
+}
+
// _BACnetAuthorizationModeTagged is the data-structure of this message
type _BACnetAuthorizationModeTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetAuthorizationModeTagged) Serialize(writeBuffer utils.WriteBuffer
return nil
}
+func (m *_BACnetAuthorizationModeTagged) isBACnetAuthorizationModeTagged() bool {
+ return true
+}
+
func (m *_BACnetAuthorizationModeTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetBDTEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetBDTEntry.go
index 22702c643f..63c6245c64 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetBDTEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetBDTEntry.go
@@ -38,6 +38,12 @@ type BACnetBDTEntry interface {
GetBroadcastMask() BACnetContextTagOctetString
}
+// BACnetBDTEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetBDTEntry.
+// This is useful for switch cases.
+type BACnetBDTEntryExactly interface {
+ isBACnetBDTEntry() bool
+}
+
// _BACnetBDTEntry is the data-structure of this message
type _BACnetBDTEntry struct {
BbmdAddress BACnetHostNPortEnclosed
@@ -197,6 +203,10 @@ func (m *_BACnetBDTEntry) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetBDTEntry) isBACnetBDTEntry() bool {
+ return true
+}
+
func (m *_BACnetBDTEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetBackupStateTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetBackupStateTagged.go
index d63dc5b5b4..169274674a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetBackupStateTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetBackupStateTagged.go
@@ -36,6 +36,12 @@ type BACnetBackupStateTagged interface {
GetValue() BACnetBackupState
}
+// BACnetBackupStateTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetBackupStateTagged.
+// This is useful for switch cases.
+type BACnetBackupStateTaggedExactly interface {
+ isBACnetBackupStateTagged() bool
+}
+
// _BACnetBackupStateTagged is the data-structure of this message
type _BACnetBackupStateTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetBackupStateTagged) Serialize(writeBuffer utils.WriteBuffer) erro
return nil
}
+func (m *_BACnetBackupStateTagged) isBACnetBackupStateTagged() bool {
+ return true
+}
+
func (m *_BACnetBackupStateTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryLightingPVTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryLightingPVTagged.go
index 60465758aa..eea7757dac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryLightingPVTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryLightingPVTagged.go
@@ -40,6 +40,12 @@ type BACnetBinaryLightingPVTagged interface {
GetIsProprietary() bool
}
+// BACnetBinaryLightingPVTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetBinaryLightingPVTagged.
+// This is useful for switch cases.
+type BACnetBinaryLightingPVTaggedExactly interface {
+ isBACnetBinaryLightingPVTagged() bool
+}
+
// _BACnetBinaryLightingPVTagged is the data-structure of this message
type _BACnetBinaryLightingPVTagged struct {
Header BACnetTagHeader
@@ -231,6 +237,10 @@ func (m *_BACnetBinaryLightingPVTagged) Serialize(writeBuffer utils.WriteBuffer)
return nil
}
+func (m *_BACnetBinaryLightingPVTagged) isBACnetBinaryLightingPVTagged() bool {
+ return true
+}
+
func (m *_BACnetBinaryLightingPVTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryPVTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryPVTagged.go
index 1721ca0ebd..e192b77b91 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryPVTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetBinaryPVTagged.go
@@ -36,6 +36,12 @@ type BACnetBinaryPVTagged interface {
GetValue() BACnetBinaryPV
}
+// BACnetBinaryPVTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetBinaryPVTagged.
+// This is useful for switch cases.
+type BACnetBinaryPVTaggedExactly interface {
+ isBACnetBinaryPVTagged() bool
+}
+
// _BACnetBinaryPVTagged is the data-structure of this message
type _BACnetBinaryPVTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetBinaryPVTagged) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetBinaryPVTagged) isBACnetBinaryPVTagged() bool {
+ return true
+}
+
func (m *_BACnetBinaryPVTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscription.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscription.go
index b7843e62e2..73d47ce1ef 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscription.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscription.go
@@ -42,6 +42,12 @@ type BACnetCOVMultipleSubscription interface {
GetListOfCovSubscriptionSpecification() BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification
}
+// BACnetCOVMultipleSubscriptionExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVMultipleSubscription.
+// This is useful for switch cases.
+type BACnetCOVMultipleSubscriptionExactly interface {
+ isBACnetCOVMultipleSubscription() bool
+}
+
// _BACnetCOVMultipleSubscription is the data-structure of this message
type _BACnetCOVMultipleSubscription struct {
Recipient BACnetRecipientProcessEnclosed
@@ -285,6 +291,10 @@ func (m *_BACnetCOVMultipleSubscription) Serialize(writeBuffer utils.WriteBuffer
return nil
}
+func (m *_BACnetCOVMultipleSubscription) isBACnetCOVMultipleSubscription() bool {
+ return true
+}
+
func (m *_BACnetCOVMultipleSubscription) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification.go
index e87d07b8c6..8ab2b2ba32 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification.go
@@ -38,6 +38,12 @@ type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification.
+// This is useful for switch cases.
+type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationExactly interface {
+ isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification() bool
+}
+
// _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification is the data-structure of this message
type _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification struct {
OpeningTag BACnetOpeningTag
@@ -233,6 +239,10 @@ func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification) Seria
return nil
}
+func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification) isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification() bool {
+ return true
+}
+
func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecification) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry.go
index 64f55e7379..2e43a3cbde 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry.go
@@ -36,6 +36,12 @@ type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry interf
GetListOfCovReferences() BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences
}
+// BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry.
+// This is useful for switch cases.
+type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryExactly interface {
+ isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry() bool
+}
+
// _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry is the data-structure of this message
type _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry struct {
MonitoredObjectIdentifier BACnetContextTagObjectIdentifier
@@ -180,6 +186,10 @@ func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry)
return nil
}
+func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry) isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry() bool {
+ return true
+}
+
func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences.go
index d49f4199a9..60ee978eee 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences.go
@@ -38,6 +38,12 @@ type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfC
GetClosingTag() BACnetClosingTag
}
+// BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences.
+// This is useful for switch cases.
+type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesExactly interface {
+ isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences() bool
+}
+
// _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences is the data-structure of this message
type _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences struct {
OpeningTag BACnetOpeningTag
@@ -233,6 +239,10 @@ func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryLi
return nil
}
+func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences) isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences() bool {
+ return true
+}
+
func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferences) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry.go
index 235cccff2a..a2141b7564 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry.go
@@ -40,6 +40,12 @@ type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfC
GetTimestamped() BACnetContextTagBoolean
}
+// BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry.
+// This is useful for switch cases.
+type BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntryExactly interface {
+ isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry() bool
+}
+
// _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry is the data-structure of this message
type _BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry struct {
MonitoredProperty BACnetPropertyReferenceEnclosed
@@ -232,6 +238,10 @@ func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryLi
return nil
}
+func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry) isBACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry() bool {
+ return true
+}
+
func (m *_BACnetCOVMultipleSubscriptionListOfCovSubscriptionSpecificationEntryListOfCovReferencesEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVSubscription.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVSubscription.go
index c416f4d57b..7d79f31579 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVSubscription.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCOVSubscription.go
@@ -44,6 +44,12 @@ type BACnetCOVSubscription interface {
GetCovIncrement() BACnetContextTagReal
}
+// BACnetCOVSubscriptionExactly can be used when we want exactly this type and not a type which fulfills BACnetCOVSubscription.
+// This is useful for switch cases.
+type BACnetCOVSubscriptionExactly interface {
+ isBACnetCOVSubscription() bool
+}
+
// _BACnetCOVSubscription is the data-structure of this message
type _BACnetCOVSubscription struct {
Recipient BACnetRecipientProcessEnclosed
@@ -302,6 +308,10 @@ func (m *_BACnetCOVSubscription) Serialize(writeBuffer utils.WriteBuffer) error
return nil
}
+func (m *_BACnetCOVSubscription) isBACnetCOVSubscription() bool {
+ return true
+}
+
func (m *_BACnetCOVSubscription) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntry.go
index 5aaba65431..abf9d02abe 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntry.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntry.go
@@ -36,6 +36,12 @@ type BACnetCalendarEntry interface {
GetPeekedTagNumber() uint8
}
+// BACnetCalendarEntryExactly can be used when we want exactly this type and not a type which fulfills BACnetCalendarEntry.
+// This is useful for switch cases.
+type BACnetCalendarEntryExactly interface {
+ isBACnetCalendarEntry() bool
+}
+
// _BACnetCalendarEntry is the data-structure of this message
type _BACnetCalendarEntry struct {
_BACnetCalendarEntryChildRequirements
@@ -43,9 +49,9 @@ type _BACnetCalendarEntry struct {
}
type _BACnetCalendarEntryChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetCalendarEntryParent interface {
@@ -54,7 +60,7 @@ type BACnetCalendarEntryParent interface {
}
type BACnetCalendarEntryChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetCalendarEntry, peekedTagHeader BACnetTagHeader)
GetParent() *BACnetCalendarEntry
@@ -207,6 +213,10 @@ func (pm *_BACnetCalendarEntry) SerializeParent(writeBuffer utils.WriteBuffer, c
return nil
}
+func (m *_BACnetCalendarEntry) isBACnetCalendarEntry() bool {
+ return true
+}
+
func (m *_BACnetCalendarEntry) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDate.go
index 455bffc13c..f31e9a2c67 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDate.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDate.go
@@ -35,6 +35,12 @@ type BACnetCalendarEntryDate interface {
GetDateValue() BACnetContextTagDate
}
+// BACnetCalendarEntryDateExactly can be used when we want exactly this type and not a type which fulfills BACnetCalendarEntryDate.
+// This is useful for switch cases.
+type BACnetCalendarEntryDateExactly interface {
+ isBACnetCalendarEntryDate() bool
+}
+
// _BACnetCalendarEntryDate is the data-structure of this message
type _BACnetCalendarEntryDate struct {
*_BACnetCalendarEntry
@@ -178,6 +184,10 @@ func (m *_BACnetCalendarEntryDate) Serialize(writeBuffer utils.WriteBuffer) erro
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetCalendarEntryDate) isBACnetCalendarEntryDate() bool {
+ return true
+}
+
func (m *_BACnetCalendarEntryDate) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDateRange.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDateRange.go
index 9272989624..808132fc9d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDateRange.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryDateRange.go
@@ -35,6 +35,12 @@ type BACnetCalendarEntryDateRange interface {
GetDateRange() BACnetDateRangeEnclosed
}
+// BACnetCalendarEntryDateRangeExactly can be used when we want exactly this type and not a type which fulfills BACnetCalendarEntryDateRange.
+// This is useful for switch cases.
+type BACnetCalendarEntryDateRangeExactly interface {
+ isBACnetCalendarEntryDateRange() bool
+}
+
// _BACnetCalendarEntryDateRange is the data-structure of this message
type _BACnetCalendarEntryDateRange struct {
*_BACnetCalendarEntry
@@ -178,6 +184,10 @@ func (m *_BACnetCalendarEntryDateRange) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetCalendarEntryDateRange) isBACnetCalendarEntryDateRange() bool {
+ return true
+}
+
func (m *_BACnetCalendarEntryDateRange) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryEnclosed.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryEnclosed.go
index f2f5adfd56..78223b6333 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryEnclosed.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryEnclosed.go
@@ -38,6 +38,12 @@ type BACnetCalendarEntryEnclosed interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetCalendarEntryEnclosedExactly can be used when we want exactly this type and not a type which fulfills BACnetCalendarEntryEnclosed.
+// This is useful for switch cases.
+type BACnetCalendarEntryEnclosedExactly interface {
+ isBACnetCalendarEntryEnclosed() bool
+}
+
// _BACnetCalendarEntryEnclosed is the data-structure of this message
type _BACnetCalendarEntryEnclosed struct {
OpeningTag BACnetOpeningTag
@@ -218,6 +224,10 @@ func (m *_BACnetCalendarEntryEnclosed) Serialize(writeBuffer utils.WriteBuffer)
return nil
}
+func (m *_BACnetCalendarEntryEnclosed) isBACnetCalendarEntryEnclosed() bool {
+ return true
+}
+
func (m *_BACnetCalendarEntryEnclosed) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryWeekNDay.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryWeekNDay.go
index b4c650748b..da647ebbc7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryWeekNDay.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetCalendarEntryWeekNDay.go
@@ -35,6 +35,12 @@ type BACnetCalendarEntryWeekNDay interface {
GetWeekNDay() BACnetWeekNDayTagged
}
+// BACnetCalendarEntryWeekNDayExactly can be used when we want exactly this type and not a type which fulfills BACnetCalendarEntryWeekNDay.
+// This is useful for switch cases.
+type BACnetCalendarEntryWeekNDayExactly interface {
+ isBACnetCalendarEntryWeekNDay() bool
+}
+
// _BACnetCalendarEntryWeekNDay is the data-structure of this message
type _BACnetCalendarEntryWeekNDay struct {
*_BACnetCalendarEntry
@@ -178,6 +184,10 @@ func (m *_BACnetCalendarEntryWeekNDay) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetCalendarEntryWeekNDay) isBACnetCalendarEntryWeekNDay() bool {
+ return true
+}
+
func (m *_BACnetCalendarEntryWeekNDay) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValue.go
index 33b8384218..668b42d136 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValue.go
@@ -38,6 +38,12 @@ type BACnetChannelValue interface {
GetPeekedIsContextTag() bool
}
+// BACnetChannelValueExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValue.
+// This is useful for switch cases.
+type BACnetChannelValueExactly interface {
+ isBACnetChannelValue() bool
+}
+
// _BACnetChannelValue is the data-structure of this message
type _BACnetChannelValue struct {
_BACnetChannelValueChildRequirements
@@ -45,9 +51,9 @@ type _BACnetChannelValue struct {
}
type _BACnetChannelValueChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetChannelValueParent interface {
@@ -56,7 +62,7 @@ type BACnetChannelValueParent interface {
}
type BACnetChannelValueChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetChannelValue, peekedTagHeader BACnetTagHeader)
GetParent() *BACnetChannelValue
@@ -246,6 +252,10 @@ func (pm *_BACnetChannelValue) SerializeParent(writeBuffer utils.WriteBuffer, ch
return nil
}
+func (m *_BACnetChannelValue) isBACnetChannelValue() bool {
+ return true
+}
+
func (m *_BACnetChannelValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBitString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBitString.go
index bacf0451cd..50e5920df3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBitString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBitString.go
@@ -35,6 +35,12 @@ type BACnetChannelValueBitString interface {
GetBitStringValue() BACnetApplicationTagBitString
}
+// BACnetChannelValueBitStringExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueBitString.
+// This is useful for switch cases.
+type BACnetChannelValueBitStringExactly interface {
+ isBACnetChannelValueBitString() bool
+}
+
// _BACnetChannelValueBitString is the data-structure of this message
type _BACnetChannelValueBitString struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueBitString) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueBitString) isBACnetChannelValueBitString() bool {
+ return true
+}
+
func (m *_BACnetChannelValueBitString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBoolean.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBoolean.go
index d01d9f4d96..c5af67e1e7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBoolean.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueBoolean.go
@@ -35,6 +35,12 @@ type BACnetChannelValueBoolean interface {
GetBooleanValue() BACnetApplicationTagBoolean
}
+// BACnetChannelValueBooleanExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueBoolean.
+// This is useful for switch cases.
+type BACnetChannelValueBooleanExactly interface {
+ isBACnetChannelValueBoolean() bool
+}
+
// _BACnetChannelValueBoolean is the data-structure of this message
type _BACnetChannelValueBoolean struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueBoolean) Serialize(writeBuffer utils.WriteBuffer) er
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueBoolean) isBACnetChannelValueBoolean() bool {
+ return true
+}
+
func (m *_BACnetChannelValueBoolean) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueCharacterString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueCharacterString.go
index fc8e04a3e1..d5a60010aa 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueCharacterString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueCharacterString.go
@@ -35,6 +35,12 @@ type BACnetChannelValueCharacterString interface {
GetCharacterStringValue() BACnetApplicationTagCharacterString
}
+// BACnetChannelValueCharacterStringExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueCharacterString.
+// This is useful for switch cases.
+type BACnetChannelValueCharacterStringExactly interface {
+ isBACnetChannelValueCharacterString() bool
+}
+
// _BACnetChannelValueCharacterString is the data-structure of this message
type _BACnetChannelValueCharacterString struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueCharacterString) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueCharacterString) isBACnetChannelValueCharacterString() bool {
+ return true
+}
+
func (m *_BACnetChannelValueCharacterString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDate.go
index 925ef6bf52..4fa964c5e3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDate.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDate.go
@@ -35,6 +35,12 @@ type BACnetChannelValueDate interface {
GetDateValue() BACnetApplicationTagDate
}
+// BACnetChannelValueDateExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueDate.
+// This is useful for switch cases.
+type BACnetChannelValueDateExactly interface {
+ isBACnetChannelValueDate() bool
+}
+
// _BACnetChannelValueDate is the data-structure of this message
type _BACnetChannelValueDate struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueDate) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueDate) isBACnetChannelValueDate() bool {
+ return true
+}
+
func (m *_BACnetChannelValueDate) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDouble.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDouble.go
index 353576b9ae..79c21b263d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDouble.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueDouble.go
@@ -35,6 +35,12 @@ type BACnetChannelValueDouble interface {
GetDoubleValue() BACnetApplicationTagDouble
}
+// BACnetChannelValueDoubleExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueDouble.
+// This is useful for switch cases.
+type BACnetChannelValueDoubleExactly interface {
+ isBACnetChannelValueDouble() bool
+}
+
// _BACnetChannelValueDouble is the data-structure of this message
type _BACnetChannelValueDouble struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueDouble) Serialize(writeBuffer utils.WriteBuffer) err
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueDouble) isBACnetChannelValueDouble() bool {
+ return true
+}
+
func (m *_BACnetChannelValueDouble) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueEnumerated.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueEnumerated.go
index 6f833ae03f..16cfdd001b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueEnumerated.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueEnumerated.go
@@ -35,6 +35,12 @@ type BACnetChannelValueEnumerated interface {
GetEnumeratedValue() BACnetApplicationTagEnumerated
}
+// BACnetChannelValueEnumeratedExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueEnumerated.
+// This is useful for switch cases.
+type BACnetChannelValueEnumeratedExactly interface {
+ isBACnetChannelValueEnumerated() bool
+}
+
// _BACnetChannelValueEnumerated is the data-structure of this message
type _BACnetChannelValueEnumerated struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueEnumerated) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueEnumerated) isBACnetChannelValueEnumerated() bool {
+ return true
+}
+
func (m *_BACnetChannelValueEnumerated) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueInteger.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueInteger.go
index b524eb8f8c..14e390137f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueInteger.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueInteger.go
@@ -35,6 +35,12 @@ type BACnetChannelValueInteger interface {
GetIntegerValue() BACnetApplicationTagSignedInteger
}
+// BACnetChannelValueIntegerExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueInteger.
+// This is useful for switch cases.
+type BACnetChannelValueIntegerExactly interface {
+ isBACnetChannelValueInteger() bool
+}
+
// _BACnetChannelValueInteger is the data-structure of this message
type _BACnetChannelValueInteger struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueInteger) Serialize(writeBuffer utils.WriteBuffer) er
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueInteger) isBACnetChannelValueInteger() bool {
+ return true
+}
+
func (m *_BACnetChannelValueInteger) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueLightingCommand.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueLightingCommand.go
index fc4ab9a43f..db7260786c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueLightingCommand.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueLightingCommand.go
@@ -35,6 +35,12 @@ type BACnetChannelValueLightingCommand interface {
GetLigthingCommandValue() BACnetLightingCommandEnclosed
}
+// BACnetChannelValueLightingCommandExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueLightingCommand.
+// This is useful for switch cases.
+type BACnetChannelValueLightingCommandExactly interface {
+ isBACnetChannelValueLightingCommand() bool
+}
+
// _BACnetChannelValueLightingCommand is the data-structure of this message
type _BACnetChannelValueLightingCommand struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueLightingCommand) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueLightingCommand) isBACnetChannelValueLightingCommand() bool {
+ return true
+}
+
func (m *_BACnetChannelValueLightingCommand) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueNull.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueNull.go
index 4004739be5..963d6b0988 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueNull.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueNull.go
@@ -35,6 +35,12 @@ type BACnetChannelValueNull interface {
GetNullValue() BACnetApplicationTagNull
}
+// BACnetChannelValueNullExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueNull.
+// This is useful for switch cases.
+type BACnetChannelValueNullExactly interface {
+ isBACnetChannelValueNull() bool
+}
+
// _BACnetChannelValueNull is the data-structure of this message
type _BACnetChannelValueNull struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueNull) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueNull) isBACnetChannelValueNull() bool {
+ return true
+}
+
func (m *_BACnetChannelValueNull) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueObjectidentifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueObjectidentifier.go
index feb4fc7810..be9cb4f4c2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueObjectidentifier.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueObjectidentifier.go
@@ -35,6 +35,12 @@ type BACnetChannelValueObjectidentifier interface {
GetObjectidentifierValue() BACnetApplicationTagObjectIdentifier
}
+// BACnetChannelValueObjectidentifierExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueObjectidentifier.
+// This is useful for switch cases.
+type BACnetChannelValueObjectidentifierExactly interface {
+ isBACnetChannelValueObjectidentifier() bool
+}
+
// _BACnetChannelValueObjectidentifier is the data-structure of this message
type _BACnetChannelValueObjectidentifier struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueObjectidentifier) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueObjectidentifier) isBACnetChannelValueObjectidentifier() bool {
+ return true
+}
+
func (m *_BACnetChannelValueObjectidentifier) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueOctetString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueOctetString.go
index cba78a4669..ef9935625f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueOctetString.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueOctetString.go
@@ -35,6 +35,12 @@ type BACnetChannelValueOctetString interface {
GetOctetStringValue() BACnetApplicationTagOctetString
}
+// BACnetChannelValueOctetStringExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueOctetString.
+// This is useful for switch cases.
+type BACnetChannelValueOctetStringExactly interface {
+ isBACnetChannelValueOctetString() bool
+}
+
// _BACnetChannelValueOctetString is the data-structure of this message
type _BACnetChannelValueOctetString struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueOctetString) Serialize(writeBuffer utils.WriteBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueOctetString) isBACnetChannelValueOctetString() bool {
+ return true
+}
+
func (m *_BACnetChannelValueOctetString) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueReal.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueReal.go
index 598be714a3..2791bba283 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueReal.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueReal.go
@@ -35,6 +35,12 @@ type BACnetChannelValueReal interface {
GetRealValue() BACnetApplicationTagReal
}
+// BACnetChannelValueRealExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueReal.
+// This is useful for switch cases.
+type BACnetChannelValueRealExactly interface {
+ isBACnetChannelValueReal() bool
+}
+
// _BACnetChannelValueReal is the data-structure of this message
type _BACnetChannelValueReal struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueReal) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueReal) isBACnetChannelValueReal() bool {
+ return true
+}
+
func (m *_BACnetChannelValueReal) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueTime.go
index 7f93bcf62c..0898ae13e4 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueTime.go
@@ -35,6 +35,12 @@ type BACnetChannelValueTime interface {
GetTimeValue() BACnetApplicationTagTime
}
+// BACnetChannelValueTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueTime.
+// This is useful for switch cases.
+type BACnetChannelValueTimeExactly interface {
+ isBACnetChannelValueTime() bool
+}
+
// _BACnetChannelValueTime is the data-structure of this message
type _BACnetChannelValueTime struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueTime) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueTime) isBACnetChannelValueTime() bool {
+ return true
+}
+
func (m *_BACnetChannelValueTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueUnsigned.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueUnsigned.go
index ddc44d34e8..05e582df23 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueUnsigned.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetChannelValueUnsigned.go
@@ -35,6 +35,12 @@ type BACnetChannelValueUnsigned interface {
GetUnsignedValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetChannelValueUnsignedExactly can be used when we want exactly this type and not a type which fulfills BACnetChannelValueUnsigned.
+// This is useful for switch cases.
+type BACnetChannelValueUnsignedExactly interface {
+ isBACnetChannelValueUnsigned() bool
+}
+
// _BACnetChannelValueUnsigned is the data-structure of this message
type _BACnetChannelValueUnsigned struct {
*_BACnetChannelValue
@@ -178,6 +184,10 @@ func (m *_BACnetChannelValueUnsigned) Serialize(writeBuffer utils.WriteBuffer) e
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetChannelValueUnsigned) isBACnetChannelValueUnsigned() bool {
+ return true
+}
+
func (m *_BACnetChannelValueUnsigned) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOV.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOV.go
index cea162a9d0..20e2da116d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOV.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOV.go
@@ -36,6 +36,12 @@ type BACnetClientCOV interface {
GetPeekedTagNumber() uint8
}
+// BACnetClientCOVExactly can be used when we want exactly this type and not a type which fulfills BACnetClientCOV.
+// This is useful for switch cases.
+type BACnetClientCOVExactly interface {
+ isBACnetClientCOV() bool
+}
+
// _BACnetClientCOV is the data-structure of this message
type _BACnetClientCOV struct {
_BACnetClientCOVChildRequirements
@@ -43,9 +49,9 @@ type _BACnetClientCOV struct {
}
type _BACnetClientCOVChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetClientCOVParent interface {
@@ -54,7 +60,7 @@ type BACnetClientCOVParent interface {
}
type BACnetClientCOVChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetClientCOV, peekedTagHeader BACnetTagHeader)
GetParent() *BACnetClientCOV
@@ -200,6 +206,10 @@ func (pm *_BACnetClientCOV) SerializeParent(writeBuffer utils.WriteBuffer, child
return nil
}
+func (m *_BACnetClientCOV) isBACnetClientCOV() bool {
+ return true
+}
+
func (m *_BACnetClientCOV) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVNone.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVNone.go
index 6257a12028..171766897e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVNone.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVNone.go
@@ -35,6 +35,12 @@ type BACnetClientCOVNone interface {
GetDefaultIncrement() BACnetApplicationTagNull
}
+// BACnetClientCOVNoneExactly can be used when we want exactly this type and not a type which fulfills BACnetClientCOVNone.
+// This is useful for switch cases.
+type BACnetClientCOVNoneExactly interface {
+ isBACnetClientCOVNone() bool
+}
+
// _BACnetClientCOVNone is the data-structure of this message
type _BACnetClientCOVNone struct {
*_BACnetClientCOV
@@ -178,6 +184,10 @@ func (m *_BACnetClientCOVNone) Serialize(writeBuffer utils.WriteBuffer) error {
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetClientCOVNone) isBACnetClientCOVNone() bool {
+ return true
+}
+
func (m *_BACnetClientCOVNone) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVObject.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVObject.go
index cb950b0b73..1b46701b49 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVObject.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetClientCOVObject.go
@@ -35,6 +35,12 @@ type BACnetClientCOVObject interface {
GetRealIncrement() BACnetApplicationTagReal
}
+// BACnetClientCOVObjectExactly can be used when we want exactly this type and not a type which fulfills BACnetClientCOVObject.
+// This is useful for switch cases.
+type BACnetClientCOVObjectExactly interface {
+ isBACnetClientCOVObject() bool
+}
+
// _BACnetClientCOVObject is the data-structure of this message
type _BACnetClientCOVObject struct {
*_BACnetClientCOV
@@ -178,6 +184,10 @@ func (m *_BACnetClientCOVObject) Serialize(writeBuffer utils.WriteBuffer) error
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetClientCOVObject) isBACnetClientCOVObject() bool {
+ return true
+}
+
func (m *_BACnetClientCOVObject) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetClosingTag.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetClosingTag.go
index 8284b1fc4f..921bd65370 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetClosingTag.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetClosingTag.go
@@ -34,6 +34,12 @@ type BACnetClosingTag interface {
GetHeader() BACnetTagHeader
}
+// BACnetClosingTagExactly can be used when we want exactly this type and not a type which fulfills BACnetClosingTag.
+// This is useful for switch cases.
+type BACnetClosingTagExactly interface {
+ isBACnetClosingTag() bool
+}
+
// _BACnetClosingTag is the data-structure of this message
type _BACnetClosingTag struct {
Header BACnetTagHeader
@@ -163,6 +169,10 @@ func (m *_BACnetClosingTag) Serialize(writeBuffer utils.WriteBuffer) error {
return nil
}
+func (m *_BACnetClosingTag) isBACnetClosingTag() bool {
+ return true
+}
+
func (m *_BACnetClosingTag) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
index 99ab36b5b4..d084ef5636 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequest interface {
GetServiceRequestPayloadLength() uint16
}
+// BACnetConfirmedServiceRequestExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequest.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestExactly interface {
+ isBACnetConfirmedServiceRequest() bool
+}
+
// _BACnetConfirmedServiceRequest is the data-structure of this message
type _BACnetConfirmedServiceRequest struct {
_BACnetConfirmedServiceRequestChildRequirements
@@ -45,10 +51,10 @@ type _BACnetConfirmedServiceRequest struct {
}
type _BACnetConfirmedServiceRequestChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetServiceChoice() BACnetConfirmedServiceChoice
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetConfirmedServiceRequestParent interface {
@@ -57,7 +63,7 @@ type BACnetConfirmedServiceRequestParent interface {
}
type BACnetConfirmedServiceRequestChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetConfirmedServiceRequest)
GetParent() *BACnetConfirmedServiceRequest
@@ -271,6 +277,10 @@ func (pm *_BACnetConfirmedServiceRequest) SerializeParent(writeBuffer utils.Writ
return nil
}
+func (m *_BACnetConfirmedServiceRequest) isBACnetConfirmedServiceRequest() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequest) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
index e0a7ab1cf9..214e37475c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
@@ -45,6 +45,12 @@ type BACnetConfirmedServiceRequestAcknowledgeAlarm interface {
GetTimeOfAcknowledgment() BACnetTimeStampEnclosed
}
+// BACnetConfirmedServiceRequestAcknowledgeAlarmExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAcknowledgeAlarm.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAcknowledgeAlarmExactly interface {
+ isBACnetConfirmedServiceRequestAcknowledgeAlarm() bool
+}
+
// _BACnetConfirmedServiceRequestAcknowledgeAlarm is the data-structure of this message
type _BACnetConfirmedServiceRequestAcknowledgeAlarm struct {
*_BACnetConfirmedServiceRequest
@@ -369,6 +375,10 @@ func (m *_BACnetConfirmedServiceRequestAcknowledgeAlarm) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAcknowledgeAlarm) isBACnetConfirmedServiceRequestAcknowledgeAlarm() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAcknowledgeAlarm) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
index 0e4abfe306..ec65b3ab59 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestAddListElement interface {
GetListOfElements() BACnetConstructedData
}
+// BACnetConfirmedServiceRequestAddListElementExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAddListElement.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAddListElementExactly interface {
+ isBACnetConfirmedServiceRequestAddListElement() bool
+}
+
// _BACnetConfirmedServiceRequestAddListElement is the data-structure of this message
type _BACnetConfirmedServiceRequestAddListElement struct {
*_BACnetConfirmedServiceRequest
@@ -327,6 +333,10 @@ func (m *_BACnetConfirmedServiceRequestAddListElement) Serialize(writeBuffer uti
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAddListElement) isBACnetConfirmedServiceRequestAddListElement() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAddListElement) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
index d031d2c77b..9e86f0bb02 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestAtomicReadFile interface {
GetAccessMethod() BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord
}
+// BACnetConfirmedServiceRequestAtomicReadFileExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAtomicReadFile.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAtomicReadFileExactly interface {
+ isBACnetConfirmedServiceRequestAtomicReadFile() bool
+}
+
// _BACnetConfirmedServiceRequestAtomicReadFile is the data-structure of this message
type _BACnetConfirmedServiceRequestAtomicReadFile struct {
*_BACnetConfirmedServiceRequest
@@ -221,6 +227,10 @@ func (m *_BACnetConfirmedServiceRequestAtomicReadFile) Serialize(writeBuffer uti
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAtomicReadFile) isBACnetConfirmedServiceRequestAtomicReadFile() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAtomicReadFile) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
index 67698c6598..26534f6af9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestAtomicReadFileRecord interface {
GetRequestRecordCount() BACnetApplicationTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestAtomicReadFileRecordExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAtomicReadFileRecord.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAtomicReadFileRecordExactly interface {
+ isBACnetConfirmedServiceRequestAtomicReadFileRecord() bool
+}
+
// _BACnetConfirmedServiceRequestAtomicReadFileRecord is the data-structure of this message
type _BACnetConfirmedServiceRequestAtomicReadFileRecord struct {
*_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord
@@ -217,6 +223,10 @@ func (m *_BACnetConfirmedServiceRequestAtomicReadFileRecord) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAtomicReadFileRecord) isBACnetConfirmedServiceRequestAtomicReadFileRecord() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAtomicReadFileRecord) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
index 22d6166b78..41be900657 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestAtomicReadFileStream interface {
GetRequestOctetCount() BACnetApplicationTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestAtomicReadFileStreamExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAtomicReadFileStream.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAtomicReadFileStreamExactly interface {
+ isBACnetConfirmedServiceRequestAtomicReadFileStream() bool
+}
+
// _BACnetConfirmedServiceRequestAtomicReadFileStream is the data-structure of this message
type _BACnetConfirmedServiceRequestAtomicReadFileStream struct {
*_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord
@@ -217,6 +223,10 @@ func (m *_BACnetConfirmedServiceRequestAtomicReadFileStream) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAtomicReadFileStream) isBACnetConfirmedServiceRequestAtomicReadFileStream() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAtomicReadFileStream) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
index f6b2b6f27e..092977a3e5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord interface {
GetPeekedTagNumber() uint8
}
+// BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordExactly interface {
+ isBACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord() bool
+}
+
// _BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord is the data-structure of this message
type _BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord struct {
_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordChildRequirements
@@ -49,9 +55,9 @@ type _BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord struct {
}
type _BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordParent interface {
@@ -60,7 +66,7 @@ type BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordParent interface {
}
type BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecordChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord, peekedTagHeader BACnetTagHeader, openingTag BACnetOpeningTag, closingTag BACnetClosingTag)
GetParent() *BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord
@@ -270,6 +276,10 @@ func (pm *_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord) SerializeP
return nil
}
+func (m *_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord) isBACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
index 4f2f0e11c5..2782c01806 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
@@ -45,6 +45,12 @@ type BACnetConfirmedServiceRequestAtomicWriteFile interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetConfirmedServiceRequestAtomicWriteFileExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAtomicWriteFile.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAtomicWriteFileExactly interface {
+ isBACnetConfirmedServiceRequestAtomicWriteFile() bool
+}
+
// _BACnetConfirmedServiceRequestAtomicWriteFile is the data-structure of this message
type _BACnetConfirmedServiceRequestAtomicWriteFile struct {
*_BACnetConfirmedServiceRequest
@@ -364,6 +370,10 @@ func (m *_BACnetConfirmedServiceRequestAtomicWriteFile) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAtomicWriteFile) isBACnetConfirmedServiceRequestAtomicWriteFile() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAtomicWriteFile) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAuthenticate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAuthenticate.go
index b21a524f2f..b503732f64 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAuthenticate.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAuthenticate.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestAuthenticate interface {
GetBytesOfRemovedService() []byte
}
+// BACnetConfirmedServiceRequestAuthenticateExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestAuthenticate.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestAuthenticateExactly interface {
+ isBACnetConfirmedServiceRequestAuthenticate() bool
+}
+
// _BACnetConfirmedServiceRequestAuthenticate is the data-structure of this message
type _BACnetConfirmedServiceRequestAuthenticate struct {
*_BACnetConfirmedServiceRequest
@@ -177,6 +183,10 @@ func (m *_BACnetConfirmedServiceRequestAuthenticate) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestAuthenticate) isBACnetConfirmedServiceRequestAuthenticate() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestAuthenticate) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
index 14b2a376f1..6b8a5b8192 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestConfirmedCOVNotification interface {
GetListOfValues() BACnetPropertyValues
}
+// BACnetConfirmedServiceRequestConfirmedCOVNotificationExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedCOVNotification.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedCOVNotificationExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedCOVNotification() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedCOVNotification is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedCOVNotification struct {
*_BACnetConfirmedServiceRequest
@@ -332,6 +338,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotification) Serialize(write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotification) isBACnetConfirmedServiceRequestConfirmedCOVNotification() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotification) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
index 54ffb79425..494174e9fc 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
@@ -45,6 +45,12 @@ type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple interface {
GetListOfCovNotifications() ListOfCovNotificationsList
}
+// BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple struct {
*_BACnetConfirmedServiceRequest
@@ -349,6 +355,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) Seriali
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) isBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
index 44fe9ab463..236dc09855 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
@@ -61,6 +61,12 @@ type BACnetConfirmedServiceRequestConfirmedEventNotification interface {
GetEventValues() BACnetNotificationParameters
}
+// BACnetConfirmedServiceRequestConfirmedEventNotificationExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedEventNotification.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedEventNotificationExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedEventNotification() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedEventNotification is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedEventNotification struct {
*_BACnetConfirmedServiceRequest
@@ -690,6 +696,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedEventNotification) Serialize(wri
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedEventNotification) isBACnetConfirmedServiceRequestConfirmedEventNotification() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedEventNotification) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
index bd1e1cd47e..51fca77198 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
@@ -41,6 +41,12 @@ type BACnetConfirmedServiceRequestConfirmedPrivateTransfer interface {
GetServiceParameters() BACnetConstructedData
}
+// BACnetConfirmedServiceRequestConfirmedPrivateTransferExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedPrivateTransfer.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedPrivateTransferExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedPrivateTransfer() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedPrivateTransfer is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedPrivateTransfer struct {
*_BACnetConfirmedServiceRequest
@@ -275,6 +281,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedPrivateTransfer) Serialize(write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedPrivateTransfer) isBACnetConfirmedServiceRequestConfirmedPrivateTransfer() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedPrivateTransfer) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
index 982a108fd2..acb725be11 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestConfirmedTextMessage interface {
GetMessage() BACnetContextTagCharacterString
}
+// BACnetConfirmedServiceRequestConfirmedTextMessageExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedTextMessage.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedTextMessageExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedTextMessage() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedTextMessage is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedTextMessage struct {
*_BACnetConfirmedServiceRequest
@@ -312,6 +318,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedTextMessage) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedTextMessage) isBACnetConfirmedServiceRequestConfirmedTextMessage() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedTextMessage) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass.go
index 888ae8e969..5667c9d365 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass interface {
GetPeekedTagNumber() uint8
}
+// BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClass() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass struct {
_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassChildRequirements
@@ -52,9 +58,9 @@ type _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass struct {
}
type _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassParent interface {
@@ -63,7 +69,7 @@ type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassParent interfa
}
type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass, openingTag BACnetOpeningTag, peekedTagHeader BACnetTagHeader, closingTag BACnetClosingTag)
GetParent() *BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass
@@ -273,6 +279,10 @@ func (pm *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass) Serial
return nil
}
+func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass) isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClass() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter.go
index 2378862af5..c290b6cd01 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter inte
GetCharacterValue() BACnetContextTagCharacterString
}
+// BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacterExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacterExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter struct {
*_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass
@@ -183,6 +189,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter) isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassCharacter) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric.go
index 021b612814..213d042370 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric interf
GetNumericValue() BACnetContextTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumericExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumericExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric struct {
*_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass
@@ -183,6 +189,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric) isBACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessageClassNumeric) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged.go
index 036934df92..bf01ba2016 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged inte
GetValue() BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriority
}
+// BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTaggedExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged
return nil
}
+func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged) isBACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedTextMessageMessagePriorityTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
index d7cbc432d7..501d7ddf54 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestConfirmedUnknown interface {
GetUnknownBytes() []byte
}
+// BACnetConfirmedServiceRequestConfirmedUnknownExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestConfirmedUnknown.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestConfirmedUnknownExactly interface {
+ isBACnetConfirmedServiceRequestConfirmedUnknown() bool
+}
+
// _BACnetConfirmedServiceRequestConfirmedUnknown is the data-structure of this message
type _BACnetConfirmedServiceRequestConfirmedUnknown struct {
*_BACnetConfirmedServiceRequest
@@ -177,6 +183,10 @@ func (m *_BACnetConfirmedServiceRequestConfirmedUnknown) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestConfirmedUnknown) isBACnetConfirmedServiceRequestConfirmedUnknown() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestConfirmedUnknown) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
index ece72410e7..b167c7be83 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
@@ -39,6 +39,12 @@ type BACnetConfirmedServiceRequestCreateObject interface {
GetListOfValues() BACnetPropertyValues
}
+// BACnetConfirmedServiceRequestCreateObjectExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestCreateObject.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestCreateObjectExactly interface {
+ isBACnetConfirmedServiceRequestCreateObject() bool
+}
+
// _BACnetConfirmedServiceRequestCreateObject is the data-structure of this message
type _BACnetConfirmedServiceRequestCreateObject struct {
*_BACnetConfirmedServiceRequest
@@ -238,6 +244,10 @@ func (m *_BACnetConfirmedServiceRequestCreateObject) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestCreateObject) isBACnetConfirmedServiceRequestCreateObject() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestCreateObject) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObjectObjectSpecifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObjectObjectSpecifier.go
index 091cd96509..0da924696a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObjectObjectSpecifier.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObjectObjectSpecifier.go
@@ -48,6 +48,12 @@ type BACnetConfirmedServiceRequestCreateObjectObjectSpecifier interface {
GetIsObjectIdentifier() bool
}
+// BACnetConfirmedServiceRequestCreateObjectObjectSpecifierExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestCreateObjectObjectSpecifier.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestCreateObjectObjectSpecifierExactly interface {
+ isBACnetConfirmedServiceRequestCreateObjectObjectSpecifier() bool
+}
+
// _BACnetConfirmedServiceRequestCreateObjectObjectSpecifier is the data-structure of this message
type _BACnetConfirmedServiceRequestCreateObjectObjectSpecifier struct {
OpeningTag BACnetOpeningTag
@@ -362,6 +368,10 @@ func (m *_BACnetConfirmedServiceRequestCreateObjectObjectSpecifier) Serialize(wr
return nil
}
+func (m *_BACnetConfirmedServiceRequestCreateObjectObjectSpecifier) isBACnetConfirmedServiceRequestCreateObjectObjectSpecifier() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestCreateObjectObjectSpecifier) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
index a2cf3fc737..ef5fa7d7d7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestDeleteObject interface {
GetObjectIdentifier() BACnetApplicationTagObjectIdentifier
}
+// BACnetConfirmedServiceRequestDeleteObjectExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestDeleteObject.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestDeleteObjectExactly interface {
+ isBACnetConfirmedServiceRequestDeleteObject() bool
+}
+
// _BACnetConfirmedServiceRequestDeleteObject is the data-structure of this message
type _BACnetConfirmedServiceRequestDeleteObject struct {
*_BACnetConfirmedServiceRequest
@@ -184,6 +190,10 @@ func (m *_BACnetConfirmedServiceRequestDeleteObject) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestDeleteObject) isBACnetConfirmedServiceRequestDeleteObject() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestDeleteObject) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
index 9e7700a756..5d544d159d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
@@ -41,6 +41,12 @@ type BACnetConfirmedServiceRequestDeviceCommunicationControl interface {
GetPassword() BACnetContextTagCharacterString
}
+// BACnetConfirmedServiceRequestDeviceCommunicationControlExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestDeviceCommunicationControl.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestDeviceCommunicationControlExactly interface {
+ isBACnetConfirmedServiceRequestDeviceCommunicationControl() bool
+}
+
// _BACnetConfirmedServiceRequestDeviceCommunicationControl is the data-structure of this message
type _BACnetConfirmedServiceRequestDeviceCommunicationControl struct {
*_BACnetConfirmedServiceRequest
@@ -290,6 +296,10 @@ func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControl) Serialize(wri
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControl) isBACnetConfirmedServiceRequestDeviceCommunicationControl() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControl) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged.go
index 0a955e66cd..335263695a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged
GetValue() BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisable
}
+// BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTaggedExactly interface {
+ isBACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged() bool
+}
+
// _BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged is the data-structure of this message
type _BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTa
return nil
}
+func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged) isBACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisableTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
index aea20185b5..46aabcbab1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
@@ -47,6 +47,12 @@ type BACnetConfirmedServiceRequestGetEnrollmentSummary interface {
GetNotificationClassFilter() BACnetContextTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestGetEnrollmentSummaryExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestGetEnrollmentSummary.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestGetEnrollmentSummaryExactly interface {
+ isBACnetConfirmedServiceRequestGetEnrollmentSummary() bool
+}
+
// _BACnetConfirmedServiceRequestGetEnrollmentSummary is the data-structure of this message
type _BACnetConfirmedServiceRequestGetEnrollmentSummary struct {
*_BACnetConfirmedServiceRequest
@@ -446,6 +452,10 @@ func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummary) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummary) isBACnetConfirmedServiceRequestGetEnrollmentSummary() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummary) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged.go
index 2aa9e43ae3..657d10f002 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagge
GetValue() BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilter
}
+// BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTaggedExactly interface {
+ isBACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged() bool
+}
+
// _BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged is the data-structure of this message
type _BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilter
return nil
}
+func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged) isBACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryAcknowledgementFilterTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged.go
index 071a8596f7..7c1cb9f345 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged int
GetValue() BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilter
}
+// BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTaggedExactly interface {
+ isBACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged() bool
+}
+
// _BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged is the data-structure of this message
type _BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagge
return nil
}
+func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged) isBACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryEventStateFilterTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter.go
index 45beeb62e5..7665652d68 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter interface {
GetClosingTag() BACnetClosingTag
}
+// BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilterExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilterExactly interface {
+ isBACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter() bool
+}
+
// _BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter is the data-structure of this message
type _BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter struct {
OpeningTag BACnetOpeningTag
@@ -253,6 +259,10 @@ func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter) Seria
return nil
}
+func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter) isBACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestGetEnrollmentSummaryPriorityFilter) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
index ff4470c6d0..44aadedee7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestGetEventInformation interface {
GetLastReceivedObjectIdentifier() BACnetContextTagObjectIdentifier
}
+// BACnetConfirmedServiceRequestGetEventInformationExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestGetEventInformation.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestGetEventInformationExactly interface {
+ isBACnetConfirmedServiceRequestGetEventInformation() bool
+}
+
// _BACnetConfirmedServiceRequestGetEventInformation is the data-structure of this message
type _BACnetConfirmedServiceRequestGetEventInformation struct {
*_BACnetConfirmedServiceRequest
@@ -201,6 +207,10 @@ func (m *_BACnetConfirmedServiceRequestGetEventInformation) Serialize(writeBuffe
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestGetEventInformation) isBACnetConfirmedServiceRequestGetEventInformation() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestGetEventInformation) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
index 551369196e..9357e0b64b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestLifeSafetyOperation interface {
GetObjectIdentifier() BACnetContextTagObjectIdentifier
}
+// BACnetConfirmedServiceRequestLifeSafetyOperationExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestLifeSafetyOperation.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestLifeSafetyOperationExactly interface {
+ isBACnetConfirmedServiceRequestLifeSafetyOperation() bool
+}
+
// _BACnetConfirmedServiceRequestLifeSafetyOperation is the data-structure of this message
type _BACnetConfirmedServiceRequestLifeSafetyOperation struct {
*_BACnetConfirmedServiceRequest
@@ -312,6 +318,10 @@ func (m *_BACnetConfirmedServiceRequestLifeSafetyOperation) Serialize(writeBuffe
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestLifeSafetyOperation) isBACnetConfirmedServiceRequestLifeSafetyOperation() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestLifeSafetyOperation) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
index a647bbe2db..1317b58052 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
@@ -41,6 +41,12 @@ type BACnetConfirmedServiceRequestReadProperty interface {
GetArrayIndex() BACnetContextTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestReadPropertyExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadProperty.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadPropertyExactly interface {
+ isBACnetConfirmedServiceRequestReadProperty() bool
+}
+
// _BACnetConfirmedServiceRequestReadProperty is the data-structure of this message
type _BACnetConfirmedServiceRequestReadProperty struct {
*_BACnetConfirmedServiceRequest
@@ -275,6 +281,10 @@ func (m *_BACnetConfirmedServiceRequestReadProperty) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadProperty) isBACnetConfirmedServiceRequestReadProperty() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadProperty) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyConditional.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyConditional.go
index 04ac1785d5..4ed5d45de3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyConditional.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyConditional.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestReadPropertyConditional interface {
GetBytesOfRemovedService() []byte
}
+// BACnetConfirmedServiceRequestReadPropertyConditionalExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadPropertyConditional.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadPropertyConditionalExactly interface {
+ isBACnetConfirmedServiceRequestReadPropertyConditional() bool
+}
+
// _BACnetConfirmedServiceRequestReadPropertyConditional is the data-structure of this message
type _BACnetConfirmedServiceRequestReadPropertyConditional struct {
*_BACnetConfirmedServiceRequest
@@ -177,6 +183,10 @@ func (m *_BACnetConfirmedServiceRequestReadPropertyConditional) Serialize(writeB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadPropertyConditional) isBACnetConfirmedServiceRequestReadPropertyConditional() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadPropertyConditional) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
index 38a76563db..305d32e5ab 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestReadPropertyMultiple interface {
GetData() []BACnetReadAccessSpecification
}
+// BACnetConfirmedServiceRequestReadPropertyMultipleExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadPropertyMultiple.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadPropertyMultipleExactly interface {
+ isBACnetConfirmedServiceRequestReadPropertyMultiple() bool
+}
+
// _BACnetConfirmedServiceRequestReadPropertyMultiple is the data-structure of this message
type _BACnetConfirmedServiceRequestReadPropertyMultiple struct {
*_BACnetConfirmedServiceRequest
@@ -201,6 +207,10 @@ func (m *_BACnetConfirmedServiceRequestReadPropertyMultiple) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadPropertyMultiple) isBACnetConfirmedServiceRequestReadPropertyMultiple() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadPropertyMultiple) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
index 2b91008ca3..1e714ea9ea 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestReadRange interface {
GetReadRange() BACnetConfirmedServiceRequestReadRangeRange
}
+// BACnetConfirmedServiceRequestReadRangeExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadRange.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadRangeExactly interface {
+ isBACnetConfirmedServiceRequestReadRange() bool
+}
+
// _BACnetConfirmedServiceRequestReadRange is the data-structure of this message
type _BACnetConfirmedServiceRequestReadRange struct {
*_BACnetConfirmedServiceRequest
@@ -327,6 +333,10 @@ func (m *_BACnetConfirmedServiceRequestReadRange) Serialize(writeBuffer utils.Wr
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadRange) isBACnetConfirmedServiceRequestReadRange() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadRange) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRange.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRange.go
index 54184c9792..60be10baf5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRange.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRange.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestReadRangeRange interface {
GetPeekedTagNumber() uint8
}
+// BACnetConfirmedServiceRequestReadRangeRangeExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadRangeRange.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadRangeRangeExactly interface {
+ isBACnetConfirmedServiceRequestReadRangeRange() bool
+}
+
// _BACnetConfirmedServiceRequestReadRangeRange is the data-structure of this message
type _BACnetConfirmedServiceRequestReadRangeRange struct {
_BACnetConfirmedServiceRequestReadRangeRangeChildRequirements
@@ -49,9 +55,9 @@ type _BACnetConfirmedServiceRequestReadRangeRange struct {
}
type _BACnetConfirmedServiceRequestReadRangeRangeChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetConfirmedServiceRequestReadRangeRangeParent interface {
@@ -60,7 +66,7 @@ type BACnetConfirmedServiceRequestReadRangeRangeParent interface {
}
type BACnetConfirmedServiceRequestReadRangeRangeChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetConfirmedServiceRequestReadRangeRange, peekedTagHeader BACnetTagHeader, openingTag BACnetOpeningTag, closingTag BACnetClosingTag)
GetParent() *BACnetConfirmedServiceRequestReadRangeRange
@@ -272,6 +278,10 @@ func (pm *_BACnetConfirmedServiceRequestReadRangeRange) SerializeParent(writeBuf
return nil
}
+func (m *_BACnetConfirmedServiceRequestReadRangeRange) isBACnetConfirmedServiceRequestReadRangeRange() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadRangeRange) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByPosition.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByPosition.go
index cbe5a89b3e..8e3aa5a1b6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByPosition.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByPosition.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestReadRangeRangeByPosition interface {
GetCount() BACnetApplicationTagSignedInteger
}
+// BACnetConfirmedServiceRequestReadRangeRangeByPositionExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadRangeRangeByPosition.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadRangeRangeByPositionExactly interface {
+ isBACnetConfirmedServiceRequestReadRangeRangeByPosition() bool
+}
+
// _BACnetConfirmedServiceRequestReadRangeRangeByPosition is the data-structure of this message
type _BACnetConfirmedServiceRequestReadRangeRangeByPosition struct {
*_BACnetConfirmedServiceRequestReadRangeRange
@@ -217,6 +223,10 @@ func (m *_BACnetConfirmedServiceRequestReadRangeRangeByPosition) Serialize(write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadRangeRangeByPosition) isBACnetConfirmedServiceRequestReadRangeRangeByPosition() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadRangeRangeByPosition) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber.go
index 444452f8cd..3e33387a1a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber interface {
GetCount() BACnetApplicationTagSignedInteger
}
+// BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumberExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumberExactly interface {
+ isBACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber() bool
+}
+
// _BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber is the data-structure of this message
type _BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber struct {
*_BACnetConfirmedServiceRequestReadRangeRange
@@ -217,6 +223,10 @@ func (m *_BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber) Serialize
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber) isBACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadRangeRangeBySequenceNumber) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByTime.go
index c98271185e..51f6432add 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRangeRangeByTime.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestReadRangeRangeByTime interface {
GetCount() BACnetApplicationTagSignedInteger
}
+// BACnetConfirmedServiceRequestReadRangeRangeByTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReadRangeRangeByTime.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReadRangeRangeByTimeExactly interface {
+ isBACnetConfirmedServiceRequestReadRangeRangeByTime() bool
+}
+
// _BACnetConfirmedServiceRequestReadRangeRangeByTime is the data-structure of this message
type _BACnetConfirmedServiceRequestReadRangeRangeByTime struct {
*_BACnetConfirmedServiceRequestReadRangeRange
@@ -217,6 +223,10 @@ func (m *_BACnetConfirmedServiceRequestReadRangeRangeByTime) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReadRangeRangeByTime) isBACnetConfirmedServiceRequestReadRangeRangeByTime() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReadRangeRangeByTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
index 4c8c8e48b7..9c35af9178 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
@@ -39,6 +39,12 @@ type BACnetConfirmedServiceRequestReinitializeDevice interface {
GetPassword() BACnetContextTagCharacterString
}
+// BACnetConfirmedServiceRequestReinitializeDeviceExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReinitializeDevice.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReinitializeDeviceExactly interface {
+ isBACnetConfirmedServiceRequestReinitializeDevice() bool
+}
+
// _BACnetConfirmedServiceRequestReinitializeDevice is the data-structure of this message
type _BACnetConfirmedServiceRequestReinitializeDevice struct {
*_BACnetConfirmedServiceRequest
@@ -238,6 +244,10 @@ func (m *_BACnetConfirmedServiceRequestReinitializeDevice) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestReinitializeDevice) isBACnetConfirmedServiceRequestReinitializeDevice() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReinitializeDevice) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged.go
index 9a90719b74..c3c5f96622 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged.go
@@ -36,6 +36,12 @@ type BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTa
GetValue() BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDevice
}
+// BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTaggedExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTaggedExactly interface {
+ isBACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged() bool
+}
+
// _BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged is the data-structure of this message
type _BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged struct {
Header BACnetTagHeader
@@ -182,6 +188,10 @@ func (m *_BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDev
return nil
}
+func (m *_BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged) isBACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestReinitializeDeviceReinitializedStateOfDeviceTagged) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
index 8b324a083a..fdca6e91f7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestRemoveListElement interface {
GetListOfElements() BACnetConstructedData
}
+// BACnetConfirmedServiceRequestRemoveListElementExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestRemoveListElement.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestRemoveListElementExactly interface {
+ isBACnetConfirmedServiceRequestRemoveListElement() bool
+}
+
// _BACnetConfirmedServiceRequestRemoveListElement is the data-structure of this message
type _BACnetConfirmedServiceRequestRemoveListElement struct {
*_BACnetConfirmedServiceRequest
@@ -327,6 +333,10 @@ func (m *_BACnetConfirmedServiceRequestRemoveListElement) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestRemoveListElement) isBACnetConfirmedServiceRequestRemoveListElement() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestRemoveListElement) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRequestKey.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRequestKey.go
index e8f1273c3d..f84acfbcaa 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRequestKey.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRequestKey.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestRequestKey interface {
GetBytesOfRemovedService() []byte
}
+// BACnetConfirmedServiceRequestRequestKeyExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestRequestKey.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestRequestKeyExactly interface {
+ isBACnetConfirmedServiceRequestRequestKey() bool
+}
+
// _BACnetConfirmedServiceRequestRequestKey is the data-structure of this message
type _BACnetConfirmedServiceRequestRequestKey struct {
*_BACnetConfirmedServiceRequest
@@ -177,6 +183,10 @@ func (m *_BACnetConfirmedServiceRequestRequestKey) Serialize(writeBuffer utils.W
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestRequestKey) isBACnetConfirmedServiceRequestRequestKey() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestRequestKey) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
index 796a856429..05f6f000c1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
@@ -43,6 +43,12 @@ type BACnetConfirmedServiceRequestSubscribeCOV interface {
GetLifetimeInSeconds() BACnetContextTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestSubscribeCOVExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOV.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOV() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOV is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOV struct {
*_BACnetConfirmedServiceRequest
@@ -327,6 +333,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOV) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOV) isBACnetConfirmedServiceRequestSubscribeCOV() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOV) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
index 9579dd082a..581ddc6c19 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
@@ -47,6 +47,12 @@ type BACnetConfirmedServiceRequestSubscribeCOVProperty interface {
GetCovIncrement() BACnetContextTagReal
}
+// BACnetConfirmedServiceRequestSubscribeCOVPropertyExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOVProperty.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVPropertyExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOVProperty() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOVProperty is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOVProperty struct {
*_BACnetConfirmedServiceRequest
@@ -416,6 +422,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOVProperty) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOVProperty) isBACnetConfirmedServiceRequestSubscribeCOVProperty() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOVProperty) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
index 4e5aa7d684..cd7f779108 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
@@ -45,6 +45,12 @@ type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple interface {
GetListOfCovSubscriptionSpecifications() BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList
}
+// BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple struct {
*_BACnetConfirmedServiceRequest
@@ -379,6 +385,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple) Serialize(w
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple) isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications.go
index 8473ec3574..ee6e59e2a9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscript
GetClosingTag() BACnetClosingTag
}
+// BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications struct {
MonitoredObjectIdentifier BACnetContextTagObjectIdentifier
@@ -265,6 +271,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubs
return nil
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications) isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecifications) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList.go
index 7f36facf78..2b1be130dc 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList.go
@@ -38,6 +38,12 @@ type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscript
GetClosingTag() BACnetClosingTag
}
+// BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsListExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsListExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList struct {
OpeningTag BACnetOpeningTag
@@ -233,6 +239,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubs
return nil
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList) isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsList) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference.go
index 3a65199851..031e85dd70 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference.go
@@ -40,6 +40,12 @@ type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscript
GetTimestamped() BACnetContextTagBoolean
}
+// BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReferenceExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReferenceExactly interface {
+ isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference() bool
+}
+
// _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference is the data-structure of this message
type _BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference struct {
MonitoredProperty BACnetPropertyReferenceEnclosed
@@ -232,6 +238,10 @@ func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubs
return nil
}
+func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference) isBACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestSubscribeCOVPropertyMultipleListOfCovSubscriptionSpecificationsReference) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
index 6bfc11b54c..ced8e1c7ae 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestVTClose interface {
GetListOfRemoteVtSessionIdentifiers() []BACnetApplicationTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestVTCloseExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestVTClose.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestVTCloseExactly interface {
+ isBACnetConfirmedServiceRequestVTClose() bool
+}
+
// _BACnetConfirmedServiceRequestVTClose is the data-structure of this message
type _BACnetConfirmedServiceRequestVTClose struct {
*_BACnetConfirmedServiceRequest
@@ -201,6 +207,10 @@ func (m *_BACnetConfirmedServiceRequestVTClose) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestVTClose) isBACnetConfirmedServiceRequestVTClose() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestVTClose) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
index 8662a60c50..05c7abfb4a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
@@ -39,6 +39,12 @@ type BACnetConfirmedServiceRequestVTData interface {
GetVtDataFlag() BACnetApplicationTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestVTDataExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestVTData.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestVTDataExactly interface {
+ isBACnetConfirmedServiceRequestVTData() bool
+}
+
// _BACnetConfirmedServiceRequestVTData is the data-structure of this message
type _BACnetConfirmedServiceRequestVTData struct {
*_BACnetConfirmedServiceRequest
@@ -258,6 +264,10 @@ func (m *_BACnetConfirmedServiceRequestVTData) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestVTData) isBACnetConfirmedServiceRequestVTData() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestVTData) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
index 843fd8c21e..7435b99713 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
@@ -37,6 +37,12 @@ type BACnetConfirmedServiceRequestVTOpen interface {
GetLocalVtSessionIdentifier() BACnetApplicationTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestVTOpenExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestVTOpen.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestVTOpenExactly interface {
+ isBACnetConfirmedServiceRequestVTOpen() bool
+}
+
// _BACnetConfirmedServiceRequestVTOpen is the data-structure of this message
type _BACnetConfirmedServiceRequestVTOpen struct {
*_BACnetConfirmedServiceRequest
@@ -221,6 +227,10 @@ func (m *_BACnetConfirmedServiceRequestVTOpen) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestVTOpen) isBACnetConfirmedServiceRequestVTOpen() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestVTOpen) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
index 080c813d68..78f20ea9e7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
@@ -45,6 +45,12 @@ type BACnetConfirmedServiceRequestWriteProperty interface {
GetPriority() BACnetContextTagUnsignedInteger
}
+// BACnetConfirmedServiceRequestWritePropertyExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestWriteProperty.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestWritePropertyExactly interface {
+ isBACnetConfirmedServiceRequestWriteProperty() bool
+}
+
// _BACnetConfirmedServiceRequestWriteProperty is the data-structure of this message
type _BACnetConfirmedServiceRequestWriteProperty struct {
*_BACnetConfirmedServiceRequest
@@ -364,6 +370,10 @@ func (m *_BACnetConfirmedServiceRequestWriteProperty) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestWriteProperty) isBACnetConfirmedServiceRequestWriteProperty() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestWriteProperty) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
index 8c5810a808..eb7504b33e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
@@ -35,6 +35,12 @@ type BACnetConfirmedServiceRequestWritePropertyMultiple interface {
GetData() []BACnetWriteAccessSpecification
}
+// BACnetConfirmedServiceRequestWritePropertyMultipleExactly can be used when we want exactly this type and not a type which fulfills BACnetConfirmedServiceRequestWritePropertyMultiple.
+// This is useful for switch cases.
+type BACnetConfirmedServiceRequestWritePropertyMultipleExactly interface {
+ isBACnetConfirmedServiceRequestWritePropertyMultiple() bool
+}
+
// _BACnetConfirmedServiceRequestWritePropertyMultiple is the data-structure of this message
type _BACnetConfirmedServiceRequestWritePropertyMultiple struct {
*_BACnetConfirmedServiceRequest
@@ -201,6 +207,10 @@ func (m *_BACnetConfirmedServiceRequestWritePropertyMultiple) Serialize(writeBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConfirmedServiceRequestWritePropertyMultiple) isBACnetConfirmedServiceRequestWritePropertyMultiple() bool {
+ return true
+}
+
func (m *_BACnetConfirmedServiceRequestWritePropertyMultiple) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
index 7a557ab54b..71a2612af3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -44,6 +44,12 @@ type BACnetConstructedData interface {
GetPeekedTagNumber() uint8
}
+// BACnetConstructedDataExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedData.
+// This is useful for switch cases.
+type BACnetConstructedDataExactly interface {
+ isBACnetConstructedData() bool
+}
+
// _BACnetConstructedData is the data-structure of this message
type _BACnetConstructedData struct {
_BACnetConstructedDataChildRequirements
@@ -57,11 +63,11 @@ type _BACnetConstructedData struct {
}
type _BACnetConstructedDataChildRequirements interface {
+ utils.Serializable
GetLengthInBits() uint16
GetLengthInBitsConditional(lastItem bool) uint16
GetObjectTypeArgument() BACnetObjectType
GetPropertyIdentifierArgument() BACnetPropertyIdentifier
- Serialize(writeBuffer utils.WriteBuffer) error
}
type BACnetConstructedDataParent interface {
@@ -70,7 +76,7 @@ type BACnetConstructedDataParent interface {
}
type BACnetConstructedDataChild interface {
- Serialize(writeBuffer utils.WriteBuffer) error
+ utils.Serializable
InitializeParent(parent BACnetConstructedData, openingTag BACnetOpeningTag, peekedTagHeader BACnetTagHeader, closingTag BACnetClosingTag)
GetParent() *BACnetConstructedData
@@ -1592,6 +1598,10 @@ func (pm *_BACnetConstructedData) SerializeParent(writeBuffer utils.WriteBuffer,
return nil
}
+func (m *_BACnetConstructedData) isBACnetConstructedData() bool {
+ return true
+}
+
func (m *_BACnetConstructedData) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
index e9eb0bff22..e9cfa40c91 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAPDULength interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAPDULengthExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAPDULength.
+// This is useful for switch cases.
+type BACnetConstructedDataAPDULengthExactly interface {
+ isBACnetConstructedDataAPDULength() bool
+}
+
// _BACnetConstructedDataAPDULength is the data-structure of this message
type _BACnetConstructedDataAPDULength struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAPDULength) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAPDULength) isBACnetConstructedDataAPDULength() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAPDULength) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
index 91c3041b58..79ad517cd9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAPDUSegmentTimeout interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAPDUSegmentTimeoutExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAPDUSegmentTimeout.
+// This is useful for switch cases.
+type BACnetConstructedDataAPDUSegmentTimeoutExactly interface {
+ isBACnetConstructedDataAPDUSegmentTimeout() bool
+}
+
// _BACnetConstructedDataAPDUSegmentTimeout is the data-structure of this message
type _BACnetConstructedDataAPDUSegmentTimeout struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAPDUSegmentTimeout) Serialize(writeBuffer utils.W
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAPDUSegmentTimeout) isBACnetConstructedDataAPDUSegmentTimeout() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAPDUSegmentTimeout) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
index 6d88b9f019..0dd536e1fe 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAPDUTimeout interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAPDUTimeoutExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAPDUTimeout.
+// This is useful for switch cases.
+type BACnetConstructedDataAPDUTimeoutExactly interface {
+ isBACnetConstructedDataAPDUTimeout() bool
+}
+
// _BACnetConstructedDataAPDUTimeout is the data-structure of this message
type _BACnetConstructedDataAPDUTimeout struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAPDUTimeout) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAPDUTimeout) isBACnetConstructedDataAPDUTimeout() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAPDUTimeout) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
index 140bc94882..3b39acf07c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAbsenteeLimit interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAbsenteeLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAbsenteeLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAbsenteeLimitExactly interface {
+ isBACnetConstructedDataAbsenteeLimit() bool
+}
+
// _BACnetConstructedDataAbsenteeLimit is the data-structure of this message
type _BACnetConstructedDataAbsenteeLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAbsenteeLimit) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAbsenteeLimit) isBACnetConstructedDataAbsenteeLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAbsenteeLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAcceptedModes.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAcceptedModes.go
index ae677f748a..761cbba71a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAcceptedModes.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAcceptedModes.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAcceptedModes interface {
GetAcceptedModes() []BACnetLifeSafetyModeTagged
}
+// BACnetConstructedDataAcceptedModesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAcceptedModes.
+// This is useful for switch cases.
+type BACnetConstructedDataAcceptedModesExactly interface {
+ isBACnetConstructedDataAcceptedModes() bool
+}
+
// _BACnetConstructedDataAcceptedModes is the data-structure of this message
type _BACnetConstructedDataAcceptedModes struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAcceptedModes) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAcceptedModes) isBACnetConstructedDataAcceptedModes() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAcceptedModes) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessAlarmEvents.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessAlarmEvents.go
index cb996a838c..2d4cc81362 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessAlarmEvents.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessAlarmEvents.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAccessAlarmEvents interface {
GetAccessAlarmEvents() []BACnetAccessEventTagged
}
+// BACnetConstructedDataAccessAlarmEventsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessAlarmEvents.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessAlarmEventsExactly interface {
+ isBACnetConstructedDataAccessAlarmEvents() bool
+}
+
// _BACnetConstructedDataAccessAlarmEvents is the data-structure of this message
type _BACnetConstructedDataAccessAlarmEvents struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAccessAlarmEvents) Serialize(writeBuffer utils.Wr
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessAlarmEvents) isBACnetConstructedDataAccessAlarmEvents() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessAlarmEvents) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessCredentialAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessCredentialAll.go
index f73678dda6..e80d12a5b8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessCredentialAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessCredentialAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessCredentialAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessCredentialAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessCredentialAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessCredentialAllExactly interface {
+ isBACnetConstructedDataAccessCredentialAll() bool
+}
+
// _BACnetConstructedDataAccessCredentialAll is the data-structure of this message
type _BACnetConstructedDataAccessCredentialAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessCredentialAll) Serialize(writeBuffer utils.
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessCredentialAll) isBACnetConstructedDataAccessCredentialAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessCredentialAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAlarmValues.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAlarmValues.go
index c5f309cbae..e398212a4d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAlarmValues.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAlarmValues.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAccessDoorAlarmValues interface {
GetAlarmValues() []BACnetDoorAlarmStateTagged
}
+// BACnetConstructedDataAccessDoorAlarmValuesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoorAlarmValues.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorAlarmValuesExactly interface {
+ isBACnetConstructedDataAccessDoorAlarmValues() bool
+}
+
// _BACnetConstructedDataAccessDoorAlarmValues is the data-structure of this message
type _BACnetConstructedDataAccessDoorAlarmValues struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAccessDoorAlarmValues) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoorAlarmValues) isBACnetConstructedDataAccessDoorAlarmValues() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoorAlarmValues) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAll.go
index b605253743..1fedf5440f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessDoorAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessDoorAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoorAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorAllExactly interface {
+ isBACnetConstructedDataAccessDoorAll() bool
+}
+
// _BACnetConstructedDataAccessDoorAll is the data-structure of this message
type _BACnetConstructedDataAccessDoorAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessDoorAll) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoorAll) isBACnetConstructedDataAccessDoorAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoorAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorFaultValues.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorFaultValues.go
index e0d0d449ed..1e14c07fcb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorFaultValues.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorFaultValues.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAccessDoorFaultValues interface {
GetFaultValues() []BACnetDoorAlarmStateTagged
}
+// BACnetConstructedDataAccessDoorFaultValuesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoorFaultValues.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorFaultValuesExactly interface {
+ isBACnetConstructedDataAccessDoorFaultValues() bool
+}
+
// _BACnetConstructedDataAccessDoorFaultValues is the data-structure of this message
type _BACnetConstructedDataAccessDoorFaultValues struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAccessDoorFaultValues) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoorFaultValues) isBACnetConstructedDataAccessDoorFaultValues() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoorFaultValues) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
index b7ac1a645d..88a6a0456d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessDoorPresentValue interface {
GetActualValue() BACnetDoorValueTagged
}
+// BACnetConstructedDataAccessDoorPresentValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoorPresentValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorPresentValueExactly interface {
+ isBACnetConstructedDataAccessDoorPresentValue() bool
+}
+
// _BACnetConstructedDataAccessDoorPresentValue is the data-structure of this message
type _BACnetConstructedDataAccessDoorPresentValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessDoorPresentValue) Serialize(writeBuffer uti
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoorPresentValue) isBACnetConstructedDataAccessDoorPresentValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoorPresentValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
index 830891fbae..a722121d69 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessDoorRelinquishDefault interface {
GetActualValue() BACnetDoorValueTagged
}
+// BACnetConstructedDataAccessDoorRelinquishDefaultExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoorRelinquishDefault.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorRelinquishDefaultExactly interface {
+ isBACnetConstructedDataAccessDoorRelinquishDefault() bool
+}
+
// _BACnetConstructedDataAccessDoorRelinquishDefault is the data-structure of this message
type _BACnetConstructedDataAccessDoorRelinquishDefault struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessDoorRelinquishDefault) Serialize(writeBuffe
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoorRelinquishDefault) isBACnetConstructedDataAccessDoorRelinquishDefault() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoorRelinquishDefault) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoors.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoors.go
index cf91007331..a1afe53f43 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoors.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoors.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAccessDoors interface {
GetZero() uint64
}
+// BACnetConstructedDataAccessDoorsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessDoors.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessDoorsExactly interface {
+ isBACnetConstructedDataAccessDoors() bool
+}
+
// _BACnetConstructedDataAccessDoors is the data-structure of this message
type _BACnetConstructedDataAccessDoors struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAccessDoors) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessDoors) isBACnetConstructedDataAccessDoors() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessDoors) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
index b92626f8dc..afe9eb41d7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessEvent interface {
GetActualValue() BACnetAccessEventTagged
}
+// BACnetConstructedDataAccessEventExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessEvent.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessEventExactly interface {
+ isBACnetConstructedDataAccessEvent() bool
+}
+
// _BACnetConstructedDataAccessEvent is the data-structure of this message
type _BACnetConstructedDataAccessEvent struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessEvent) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessEvent) isBACnetConstructedDataAccessEvent() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessEvent) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
index 7ecd3c6ee3..e389a1b766 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessEventAuthenticationFactor interface {
GetActualValue() BACnetAuthenticationFactor
}
+// BACnetConstructedDataAccessEventAuthenticationFactorExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessEventAuthenticationFactor.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessEventAuthenticationFactorExactly interface {
+ isBACnetConstructedDataAccessEventAuthenticationFactor() bool
+}
+
// _BACnetConstructedDataAccessEventAuthenticationFactor is the data-structure of this message
type _BACnetConstructedDataAccessEventAuthenticationFactor struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessEventAuthenticationFactor) Serialize(writeB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessEventAuthenticationFactor) isBACnetConstructedDataAccessEventAuthenticationFactor() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessEventAuthenticationFactor) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
index ca2d297a27..09995caa37 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessEventCredential interface {
GetActualValue() BACnetDeviceObjectReference
}
+// BACnetConstructedDataAccessEventCredentialExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessEventCredential.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessEventCredentialExactly interface {
+ isBACnetConstructedDataAccessEventCredential() bool
+}
+
// _BACnetConstructedDataAccessEventCredential is the data-structure of this message
type _BACnetConstructedDataAccessEventCredential struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessEventCredential) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessEventCredential) isBACnetConstructedDataAccessEventCredential() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessEventCredential) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
index 216516548b..baa4249cef 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessEventTag interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccessEventTagExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessEventTag.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessEventTagExactly interface {
+ isBACnetConstructedDataAccessEventTag() bool
+}
+
// _BACnetConstructedDataAccessEventTag is the data-structure of this message
type _BACnetConstructedDataAccessEventTag struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessEventTag) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessEventTag) isBACnetConstructedDataAccessEventTag() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessEventTag) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
index eb4d85b067..18c22f23f3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessEventTime interface {
GetActualValue() BACnetTimeStamp
}
+// BACnetConstructedDataAccessEventTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessEventTime.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessEventTimeExactly interface {
+ isBACnetConstructedDataAccessEventTime() bool
+}
+
// _BACnetConstructedDataAccessEventTime is the data-structure of this message
type _BACnetConstructedDataAccessEventTime struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessEventTime) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessEventTime) isBACnetConstructedDataAccessEventTime() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessEventTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessPointAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessPointAll.go
index 7724c2cb2f..1e58819086 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessPointAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessPointAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessPointAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessPointAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessPointAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessPointAllExactly interface {
+ isBACnetConstructedDataAccessPointAll() bool
+}
+
// _BACnetConstructedDataAccessPointAll is the data-structure of this message
type _BACnetConstructedDataAccessPointAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessPointAll) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessPointAll) isBACnetConstructedDataAccessPointAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessPointAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessRightsAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessRightsAll.go
index 5900d389d7..e18273570a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessRightsAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessRightsAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessRightsAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessRightsAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessRightsAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessRightsAllExactly interface {
+ isBACnetConstructedDataAccessRightsAll() bool
+}
+
// _BACnetConstructedDataAccessRightsAll is the data-structure of this message
type _BACnetConstructedDataAccessRightsAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessRightsAll) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessRightsAll) isBACnetConstructedDataAccessRightsAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessRightsAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessTransactionEvents.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessTransactionEvents.go
index 0852ffcbe1..3e6f1bf970 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessTransactionEvents.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessTransactionEvents.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAccessTransactionEvents interface {
GetAccessTransactionEvents() []BACnetAccessEventTagged
}
+// BACnetConstructedDataAccessTransactionEventsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessTransactionEvents.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessTransactionEventsExactly interface {
+ isBACnetConstructedDataAccessTransactionEvents() bool
+}
+
// _BACnetConstructedDataAccessTransactionEvents is the data-structure of this message
type _BACnetConstructedDataAccessTransactionEvents struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAccessTransactionEvents) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessTransactionEvents) isBACnetConstructedDataAccessTransactionEvents() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessTransactionEvents) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessUserAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessUserAll.go
index 9af3ae351e..b937d02396 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessUserAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessUserAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessUserAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessUserAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessUserAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessUserAllExactly interface {
+ isBACnetConstructedDataAccessUserAll() bool
+}
+
// _BACnetConstructedDataAccessUserAll is the data-structure of this message
type _BACnetConstructedDataAccessUserAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessUserAll) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessUserAll) isBACnetConstructedDataAccessUserAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessUserAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
index 90130c3e25..15f3768b75 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccessZoneAdjustValue interface {
GetActualValue() BACnetApplicationTagSignedInteger
}
+// BACnetConstructedDataAccessZoneAdjustValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessZoneAdjustValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessZoneAdjustValueExactly interface {
+ isBACnetConstructedDataAccessZoneAdjustValue() bool
+}
+
// _BACnetConstructedDataAccessZoneAdjustValue is the data-structure of this message
type _BACnetConstructedDataAccessZoneAdjustValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccessZoneAdjustValue) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessZoneAdjustValue) isBACnetConstructedDataAccessZoneAdjustValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessZoneAdjustValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAlarmValues.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAlarmValues.go
index 458c4b47fe..6a9c29d6aa 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAlarmValues.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAlarmValues.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAccessZoneAlarmValues interface {
GetAlarmValues() []BACnetAccessZoneOccupancyStateTagged
}
+// BACnetConstructedDataAccessZoneAlarmValuesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessZoneAlarmValues.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessZoneAlarmValuesExactly interface {
+ isBACnetConstructedDataAccessZoneAlarmValues() bool
+}
+
// _BACnetConstructedDataAccessZoneAlarmValues is the data-structure of this message
type _BACnetConstructedDataAccessZoneAlarmValues struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAccessZoneAlarmValues) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessZoneAlarmValues) isBACnetConstructedDataAccessZoneAlarmValues() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessZoneAlarmValues) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAll.go
index 3a10fbd80e..b4f5881889 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccessZoneAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccessZoneAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccessZoneAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccessZoneAllExactly interface {
+ isBACnetConstructedDataAccessZoneAll() bool
+}
+
// _BACnetConstructedDataAccessZoneAll is the data-structure of this message
type _BACnetConstructedDataAccessZoneAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccessZoneAll) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccessZoneAll) isBACnetConstructedDataAccessZoneAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccessZoneAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
index 93f67353c0..2e728355e8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccompaniment interface {
GetActualValue() BACnetDeviceObjectReference
}
+// BACnetConstructedDataAccompanimentExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccompaniment.
+// This is useful for switch cases.
+type BACnetConstructedDataAccompanimentExactly interface {
+ isBACnetConstructedDataAccompaniment() bool
+}
+
// _BACnetConstructedDataAccompaniment is the data-structure of this message
type _BACnetConstructedDataAccompaniment struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccompaniment) Serialize(writeBuffer utils.WriteB
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccompaniment) isBACnetConstructedDataAccompaniment() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccompaniment) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
index 2f530fb40e..605893cfe9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccompanimentTime interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccompanimentTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccompanimentTime.
+// This is useful for switch cases.
+type BACnetConstructedDataAccompanimentTimeExactly interface {
+ isBACnetConstructedDataAccompanimentTime() bool
+}
+
// _BACnetConstructedDataAccompanimentTime is the data-structure of this message
type _BACnetConstructedDataAccompanimentTime struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccompanimentTime) Serialize(writeBuffer utils.Wr
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccompanimentTime) isBACnetConstructedDataAccompanimentTime() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccompanimentTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorAll.go
index ac703623c1..d45692c3e1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAccumulatorAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAccumulatorAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorAllExactly interface {
+ isBACnetConstructedDataAccumulatorAll() bool
+}
+
// _BACnetConstructedDataAccumulatorAll is the data-structure of this message
type _BACnetConstructedDataAccumulatorAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAccumulatorAll) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorAll) isBACnetConstructedDataAccumulatorAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
index 8697bca096..6290c3c7ce 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorFaultHighLimit interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorFaultHighLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorFaultHighLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorFaultHighLimitExactly interface {
+ isBACnetConstructedDataAccumulatorFaultHighLimit() bool
+}
+
// _BACnetConstructedDataAccumulatorFaultHighLimit is the data-structure of this message
type _BACnetConstructedDataAccumulatorFaultHighLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorFaultHighLimit) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorFaultHighLimit) isBACnetConstructedDataAccumulatorFaultHighLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorFaultHighLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
index a93b980a26..30e17c345f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorFaultLowLimit interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorFaultLowLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorFaultLowLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorFaultLowLimitExactly interface {
+ isBACnetConstructedDataAccumulatorFaultLowLimit() bool
+}
+
// _BACnetConstructedDataAccumulatorFaultLowLimit is the data-structure of this message
type _BACnetConstructedDataAccumulatorFaultLowLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorFaultLowLimit) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorFaultLowLimit) isBACnetConstructedDataAccumulatorFaultLowLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorFaultLowLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
index 11ebe2c7e1..61ac8c2ecc 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorHighLimit interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorHighLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorHighLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorHighLimitExactly interface {
+ isBACnetConstructedDataAccumulatorHighLimit() bool
+}
+
// _BACnetConstructedDataAccumulatorHighLimit is the data-structure of this message
type _BACnetConstructedDataAccumulatorHighLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorHighLimit) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorHighLimit) isBACnetConstructedDataAccumulatorHighLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorHighLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
index 6327462aaf..0cce99b07c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorLowLimit interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorLowLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorLowLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorLowLimitExactly interface {
+ isBACnetConstructedDataAccumulatorLowLimit() bool
+}
+
// _BACnetConstructedDataAccumulatorLowLimit is the data-structure of this message
type _BACnetConstructedDataAccumulatorLowLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorLowLimit) Serialize(writeBuffer utils.
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorLowLimit) isBACnetConstructedDataAccumulatorLowLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorLowLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
index 61ab3a1cc6..626f9785dd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorMaxPresValue interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorMaxPresValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorMaxPresValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorMaxPresValueExactly interface {
+ isBACnetConstructedDataAccumulatorMaxPresValue() bool
+}
+
// _BACnetConstructedDataAccumulatorMaxPresValue is the data-structure of this message
type _BACnetConstructedDataAccumulatorMaxPresValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorMaxPresValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorMaxPresValue) isBACnetConstructedDataAccumulatorMaxPresValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorMaxPresValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
index 1a17d4fa40..c3557d6eda 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAccumulatorMinPresValue interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAccumulatorMinPresValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAccumulatorMinPresValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAccumulatorMinPresValueExactly interface {
+ isBACnetConstructedDataAccumulatorMinPresValue() bool
+}
+
// _BACnetConstructedDataAccumulatorMinPresValue is the data-structure of this message
type _BACnetConstructedDataAccumulatorMinPresValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAccumulatorMinPresValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAccumulatorMinPresValue) isBACnetConstructedDataAccumulatorMinPresValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAccumulatorMinPresValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
index 237433f511..d2e74cde88 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAckRequired interface {
GetActualValue() BACnetEventTransitionBitsTagged
}
+// BACnetConstructedDataAckRequiredExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAckRequired.
+// This is useful for switch cases.
+type BACnetConstructedDataAckRequiredExactly interface {
+ isBACnetConstructedDataAckRequired() bool
+}
+
// _BACnetConstructedDataAckRequired is the data-structure of this message
type _BACnetConstructedDataAckRequired struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAckRequired) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAckRequired) isBACnetConstructedDataAckRequired() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAckRequired) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
index 784f91a22e..7cf92e3bd9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAckedTransitions interface {
GetActualValue() BACnetEventTransitionBitsTagged
}
+// BACnetConstructedDataAckedTransitionsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAckedTransitions.
+// This is useful for switch cases.
+type BACnetConstructedDataAckedTransitionsExactly interface {
+ isBACnetConstructedDataAckedTransitions() bool
+}
+
// _BACnetConstructedDataAckedTransitions is the data-structure of this message
type _BACnetConstructedDataAckedTransitions struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAckedTransitions) Serialize(writeBuffer utils.Wri
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAckedTransitions) isBACnetConstructedDataAckedTransitions() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAckedTransitions) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAction.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAction.go
index cd61bbbc2e..f1ac9061cf 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAction.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAction.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAction interface {
GetZero() uint64
}
+// BACnetConstructedDataActionExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAction.
+// This is useful for switch cases.
+type BACnetConstructedDataActionExactly interface {
+ isBACnetConstructedDataAction() bool
+}
+
// _BACnetConstructedDataAction is the data-structure of this message
type _BACnetConstructedDataAction struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAction) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAction) isBACnetConstructedDataAction() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAction) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActionText.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActionText.go
index 7ad4245b44..0d0d61ac4e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActionText.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActionText.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataActionText interface {
GetZero() uint64
}
+// BACnetConstructedDataActionTextExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActionText.
+// This is useful for switch cases.
+type BACnetConstructedDataActionTextExactly interface {
+ isBACnetConstructedDataActionText() bool
+}
+
// _BACnetConstructedDataActionText is the data-structure of this message
type _BACnetConstructedDataActionText struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataActionText) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActionText) isBACnetConstructedDataActionText() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActionText) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
index fc70968b0e..e773f03788 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataActivationTime interface {
GetActualValue() BACnetDateTime
}
+// BACnetConstructedDataActivationTimeExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActivationTime.
+// This is useful for switch cases.
+type BACnetConstructedDataActivationTimeExactly interface {
+ isBACnetConstructedDataActivationTime() bool
+}
+
// _BACnetConstructedDataActivationTime is the data-structure of this message
type _BACnetConstructedDataActivationTime struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataActivationTime) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActivationTime) isBACnetConstructedDataActivationTime() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActivationTime) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
index 11c471ed0b..b0653c579e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataActiveAuthenticationPolicy interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataActiveAuthenticationPolicyExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActiveAuthenticationPolicy.
+// This is useful for switch cases.
+type BACnetConstructedDataActiveAuthenticationPolicyExactly interface {
+ isBACnetConstructedDataActiveAuthenticationPolicy() bool
+}
+
// _BACnetConstructedDataActiveAuthenticationPolicy is the data-structure of this message
type _BACnetConstructedDataActiveAuthenticationPolicy struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataActiveAuthenticationPolicy) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActiveAuthenticationPolicy) isBACnetConstructedDataActiveAuthenticationPolicy() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActiveAuthenticationPolicy) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVMultipleSubscriptions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVMultipleSubscriptions.go
index 804c4a8951..95d13b2ecc 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVMultipleSubscriptions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVMultipleSubscriptions.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataActiveCOVMultipleSubscriptions interface {
GetActiveCOVMultipleSubscriptions() []BACnetCOVMultipleSubscription
}
+// BACnetConstructedDataActiveCOVMultipleSubscriptionsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActiveCOVMultipleSubscriptions.
+// This is useful for switch cases.
+type BACnetConstructedDataActiveCOVMultipleSubscriptionsExactly interface {
+ isBACnetConstructedDataActiveCOVMultipleSubscriptions() bool
+}
+
// _BACnetConstructedDataActiveCOVMultipleSubscriptions is the data-structure of this message
type _BACnetConstructedDataActiveCOVMultipleSubscriptions struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataActiveCOVMultipleSubscriptions) Serialize(writeBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActiveCOVMultipleSubscriptions) isBACnetConstructedDataActiveCOVMultipleSubscriptions() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActiveCOVMultipleSubscriptions) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVSubscriptions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVSubscriptions.go
index 1cfe6c71f6..1372214363 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVSubscriptions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveCOVSubscriptions.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataActiveCOVSubscriptions interface {
GetActiveCOVSubscriptions() []BACnetCOVSubscription
}
+// BACnetConstructedDataActiveCOVSubscriptionsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActiveCOVSubscriptions.
+// This is useful for switch cases.
+type BACnetConstructedDataActiveCOVSubscriptionsExactly interface {
+ isBACnetConstructedDataActiveCOVSubscriptions() bool
+}
+
// _BACnetConstructedDataActiveCOVSubscriptions is the data-structure of this message
type _BACnetConstructedDataActiveCOVSubscriptions struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataActiveCOVSubscriptions) Serialize(writeBuffer uti
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActiveCOVSubscriptions) isBACnetConstructedDataActiveCOVSubscriptions() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActiveCOVSubscriptions) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
index 4b6f7ca4a2..3cf6830e18 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataActiveText interface {
GetActualValue() BACnetApplicationTagCharacterString
}
+// BACnetConstructedDataActiveTextExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActiveText.
+// This is useful for switch cases.
+type BACnetConstructedDataActiveTextExactly interface {
+ isBACnetConstructedDataActiveText() bool
+}
+
// _BACnetConstructedDataActiveText is the data-structure of this message
type _BACnetConstructedDataActiveText struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataActiveText) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActiveText) isBACnetConstructedDataActiveText() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActiveText) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveVTSessions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveVTSessions.go
index fd0529195c..fd5f70c864 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveVTSessions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveVTSessions.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataActiveVTSessions interface {
GetActiveVTSession() []BACnetVTSession
}
+// BACnetConstructedDataActiveVTSessionsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActiveVTSessions.
+// This is useful for switch cases.
+type BACnetConstructedDataActiveVTSessionsExactly interface {
+ isBACnetConstructedDataActiveVTSessions() bool
+}
+
// _BACnetConstructedDataActiveVTSessions is the data-structure of this message
type _BACnetConstructedDataActiveVTSessions struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataActiveVTSessions) Serialize(writeBuffer utils.Wri
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActiveVTSessions) isBACnetConstructedDataActiveVTSessions() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActiveVTSessions) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
index 1ad06b3bcc..dd0818e9fb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataActualShedLevel interface {
GetActualValue() BACnetShedLevel
}
+// BACnetConstructedDataActualShedLevelExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataActualShedLevel.
+// This is useful for switch cases.
+type BACnetConstructedDataActualShedLevelExactly interface {
+ isBACnetConstructedDataActualShedLevel() bool
+}
+
// _BACnetConstructedDataActualShedLevel is the data-structure of this message
type _BACnetConstructedDataActualShedLevel struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataActualShedLevel) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataActualShedLevel) isBACnetConstructedDataActualShedLevel() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataActualShedLevel) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
index fed4c09315..915e81a8a5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAdjustValue interface {
GetActualValue() BACnetApplicationTagSignedInteger
}
+// BACnetConstructedDataAdjustValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAdjustValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAdjustValueExactly interface {
+ isBACnetConstructedDataAdjustValue() bool
+}
+
// _BACnetConstructedDataAdjustValue is the data-structure of this message
type _BACnetConstructedDataAdjustValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAdjustValue) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAdjustValue) isBACnetConstructedDataAdjustValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAdjustValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
index 6f31613f52..ff1cd9d38a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAlarmValue interface {
GetActualValue() BACnetBinaryPVTagged
}
+// BACnetConstructedDataAlarmValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAlarmValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAlarmValueExactly interface {
+ isBACnetConstructedDataAlarmValue() bool
+}
+
// _BACnetConstructedDataAlarmValue is the data-structure of this message
type _BACnetConstructedDataAlarmValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAlarmValue) Serialize(writeBuffer utils.WriteBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAlarmValue) isBACnetConstructedDataAlarmValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAlarmValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValues.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValues.go
index 3f294a88b0..8714f88ef8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValues.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValues.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAlarmValues interface {
GetZero() uint64
}
+// BACnetConstructedDataAlarmValuesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAlarmValues.
+// This is useful for switch cases.
+type BACnetConstructedDataAlarmValuesExactly interface {
+ isBACnetConstructedDataAlarmValues() bool
+}
+
// _BACnetConstructedDataAlarmValues is the data-structure of this message
type _BACnetConstructedDataAlarmValues struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAlarmValues) Serialize(writeBuffer utils.WriteBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAlarmValues) isBACnetConstructedDataAlarmValues() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAlarmValues) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentAll.go
index 785ba68668..ff13f2d3c5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAlertEnrollmentAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAlertEnrollmentAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAlertEnrollmentAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAlertEnrollmentAllExactly interface {
+ isBACnetConstructedDataAlertEnrollmentAll() bool
+}
+
// _BACnetConstructedDataAlertEnrollmentAll is the data-structure of this message
type _BACnetConstructedDataAlertEnrollmentAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAlertEnrollmentAll) Serialize(writeBuffer utils.W
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAlertEnrollmentAll) isBACnetConstructedDataAlertEnrollmentAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAlertEnrollmentAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
index 6d26951dee..4c0bb20f48 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAlertEnrollmentPresentValue interface {
GetActualValue() BACnetApplicationTagObjectIdentifier
}
+// BACnetConstructedDataAlertEnrollmentPresentValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAlertEnrollmentPresentValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAlertEnrollmentPresentValueExactly interface {
+ isBACnetConstructedDataAlertEnrollmentPresentValue() bool
+}
+
// _BACnetConstructedDataAlertEnrollmentPresentValue is the data-structure of this message
type _BACnetConstructedDataAlertEnrollmentPresentValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAlertEnrollmentPresentValue) Serialize(writeBuffe
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAlertEnrollmentPresentValue) isBACnetConstructedDataAlertEnrollmentPresentValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAlertEnrollmentPresentValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
index 166a010974..ceceaafcac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAlignIntervals interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataAlignIntervalsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAlignIntervals.
+// This is useful for switch cases.
+type BACnetConstructedDataAlignIntervalsExactly interface {
+ isBACnetConstructedDataAlignIntervals() bool
+}
+
// _BACnetConstructedDataAlignIntervals is the data-structure of this message
type _BACnetConstructedDataAlignIntervals struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAlignIntervals) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAlignIntervals) isBACnetConstructedDataAlignIntervals() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAlignIntervals) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
index eefe9371f4..b0b244e481 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAllWritesSuccessful interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataAllWritesSuccessfulExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAllWritesSuccessful.
+// This is useful for switch cases.
+type BACnetConstructedDataAllWritesSuccessfulExactly interface {
+ isBACnetConstructedDataAllWritesSuccessful() bool
+}
+
// _BACnetConstructedDataAllWritesSuccessful is the data-structure of this message
type _BACnetConstructedDataAllWritesSuccessful struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAllWritesSuccessful) Serialize(writeBuffer utils.
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAllWritesSuccessful) isBACnetConstructedDataAllWritesSuccessful() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAllWritesSuccessful) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
index ce58a6428f..83c0206d22 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAllowGroupDelayInhibit interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataAllowGroupDelayInhibitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAllowGroupDelayInhibit.
+// This is useful for switch cases.
+type BACnetConstructedDataAllowGroupDelayInhibitExactly interface {
+ isBACnetConstructedDataAllowGroupDelayInhibit() bool
+}
+
// _BACnetConstructedDataAllowGroupDelayInhibit is the data-structure of this message
type _BACnetConstructedDataAllowGroupDelayInhibit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAllowGroupDelayInhibit) Serialize(writeBuffer uti
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAllowGroupDelayInhibit) isBACnetConstructedDataAllowGroupDelayInhibit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAllowGroupDelayInhibit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputAll.go
index 16c1329a6d..7cc56c1d4b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAnalogInputAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAnalogInputAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputAllExactly interface {
+ isBACnetConstructedDataAnalogInputAll() bool
+}
+
// _BACnetConstructedDataAnalogInputAll is the data-structure of this message
type _BACnetConstructedDataAnalogInputAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAnalogInputAll) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputAll) isBACnetConstructedDataAnalogInputAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
index 6e6c324fff..d294c1234e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogInputFaultHighLimit interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogInputFaultHighLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputFaultHighLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputFaultHighLimitExactly interface {
+ isBACnetConstructedDataAnalogInputFaultHighLimit() bool
+}
+
// _BACnetConstructedDataAnalogInputFaultHighLimit is the data-structure of this message
type _BACnetConstructedDataAnalogInputFaultHighLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogInputFaultHighLimit) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputFaultHighLimit) isBACnetConstructedDataAnalogInputFaultHighLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputFaultHighLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
index b7d3896027..4d84ec44e2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogInputFaultLowLimit interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogInputFaultLowLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputFaultLowLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputFaultLowLimitExactly interface {
+ isBACnetConstructedDataAnalogInputFaultLowLimit() bool
+}
+
// _BACnetConstructedDataAnalogInputFaultLowLimit is the data-structure of this message
type _BACnetConstructedDataAnalogInputFaultLowLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogInputFaultLowLimit) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputFaultLowLimit) isBACnetConstructedDataAnalogInputFaultLowLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputFaultLowLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
index 65e4497ee6..6b804e945d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogInputInterfaceValue interface {
GetActualValue() BACnetOptionalREAL
}
+// BACnetConstructedDataAnalogInputInterfaceValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputInterfaceValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputInterfaceValueExactly interface {
+ isBACnetConstructedDataAnalogInputInterfaceValue() bool
+}
+
// _BACnetConstructedDataAnalogInputInterfaceValue is the data-structure of this message
type _BACnetConstructedDataAnalogInputInterfaceValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogInputInterfaceValue) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputInterfaceValue) isBACnetConstructedDataAnalogInputInterfaceValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputInterfaceValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
index f54e1f7edd..1140a99e2a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogInputMaxPresValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogInputMaxPresValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputMaxPresValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputMaxPresValueExactly interface {
+ isBACnetConstructedDataAnalogInputMaxPresValue() bool
+}
+
// _BACnetConstructedDataAnalogInputMaxPresValue is the data-structure of this message
type _BACnetConstructedDataAnalogInputMaxPresValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogInputMaxPresValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputMaxPresValue) isBACnetConstructedDataAnalogInputMaxPresValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputMaxPresValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
index d3ce229429..4a9f3b52ec 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogInputPresentValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogInputPresentValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogInputPresentValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogInputPresentValueExactly interface {
+ isBACnetConstructedDataAnalogInputPresentValue() bool
+}
+
// _BACnetConstructedDataAnalogInputPresentValue is the data-structure of this message
type _BACnetConstructedDataAnalogInputPresentValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogInputPresentValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogInputPresentValue) isBACnetConstructedDataAnalogInputPresentValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogInputPresentValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputAll.go
index 1e14b9dd63..888ed50fc9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAnalogOutputAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAnalogOutputAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogOutputAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogOutputAllExactly interface {
+ isBACnetConstructedDataAnalogOutputAll() bool
+}
+
// _BACnetConstructedDataAnalogOutputAll is the data-structure of this message
type _BACnetConstructedDataAnalogOutputAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAnalogOutputAll) Serialize(writeBuffer utils.Writ
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogOutputAll) isBACnetConstructedDataAnalogOutputAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogOutputAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
index 1659bc27a1..53fc3ce20c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogOutputInterfaceValue interface {
GetActualValue() BACnetOptionalREAL
}
+// BACnetConstructedDataAnalogOutputInterfaceValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogOutputInterfaceValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogOutputInterfaceValueExactly interface {
+ isBACnetConstructedDataAnalogOutputInterfaceValue() bool
+}
+
// _BACnetConstructedDataAnalogOutputInterfaceValue is the data-structure of this message
type _BACnetConstructedDataAnalogOutputInterfaceValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogOutputInterfaceValue) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogOutputInterfaceValue) isBACnetConstructedDataAnalogOutputInterfaceValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogOutputInterfaceValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
index e4ab4a190d..261064fd94 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogOutputMaxPresValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogOutputMaxPresValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogOutputMaxPresValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogOutputMaxPresValueExactly interface {
+ isBACnetConstructedDataAnalogOutputMaxPresValue() bool
+}
+
// _BACnetConstructedDataAnalogOutputMaxPresValue is the data-structure of this message
type _BACnetConstructedDataAnalogOutputMaxPresValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogOutputMaxPresValue) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogOutputMaxPresValue) isBACnetConstructedDataAnalogOutputMaxPresValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogOutputMaxPresValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
index e110789a49..73648b44cb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogOutputPresentValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogOutputPresentValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogOutputPresentValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogOutputPresentValueExactly interface {
+ isBACnetConstructedDataAnalogOutputPresentValue() bool
+}
+
// _BACnetConstructedDataAnalogOutputPresentValue is the data-structure of this message
type _BACnetConstructedDataAnalogOutputPresentValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogOutputPresentValue) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogOutputPresentValue) isBACnetConstructedDataAnalogOutputPresentValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogOutputPresentValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
index 562df39ddf..c0fff8af91 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogOutputRelinquishDefault interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogOutputRelinquishDefaultExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogOutputRelinquishDefault.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogOutputRelinquishDefaultExactly interface {
+ isBACnetConstructedDataAnalogOutputRelinquishDefault() bool
+}
+
// _BACnetConstructedDataAnalogOutputRelinquishDefault is the data-structure of this message
type _BACnetConstructedDataAnalogOutputRelinquishDefault struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogOutputRelinquishDefault) Serialize(writeBuf
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogOutputRelinquishDefault) isBACnetConstructedDataAnalogOutputRelinquishDefault() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogOutputRelinquishDefault) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueAll.go
index 48aac397f5..c0e605b1ac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAnalogValueAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAnalogValueAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValueAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValueAllExactly interface {
+ isBACnetConstructedDataAnalogValueAll() bool
+}
+
// _BACnetConstructedDataAnalogValueAll is the data-structure of this message
type _BACnetConstructedDataAnalogValueAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAnalogValueAll) Serialize(writeBuffer utils.Write
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValueAll) isBACnetConstructedDataAnalogValueAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValueAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
index e5cf646e8d..847f624bd1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogValueFaultHighLimit interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogValueFaultHighLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValueFaultHighLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValueFaultHighLimitExactly interface {
+ isBACnetConstructedDataAnalogValueFaultHighLimit() bool
+}
+
// _BACnetConstructedDataAnalogValueFaultHighLimit is the data-structure of this message
type _BACnetConstructedDataAnalogValueFaultHighLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogValueFaultHighLimit) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValueFaultHighLimit) isBACnetConstructedDataAnalogValueFaultHighLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValueFaultHighLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
index 4b9e3c6f3c..f3a9b7c7bb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogValueFaultLowLimit interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogValueFaultLowLimitExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValueFaultLowLimit.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValueFaultLowLimitExactly interface {
+ isBACnetConstructedDataAnalogValueFaultLowLimit() bool
+}
+
// _BACnetConstructedDataAnalogValueFaultLowLimit is the data-structure of this message
type _BACnetConstructedDataAnalogValueFaultLowLimit struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogValueFaultLowLimit) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValueFaultLowLimit) isBACnetConstructedDataAnalogValueFaultLowLimit() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValueFaultLowLimit) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
index 801f3acd4f..f6455649df 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogValueMaxPresValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogValueMaxPresValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValueMaxPresValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValueMaxPresValueExactly interface {
+ isBACnetConstructedDataAnalogValueMaxPresValue() bool
+}
+
// _BACnetConstructedDataAnalogValueMaxPresValue is the data-structure of this message
type _BACnetConstructedDataAnalogValueMaxPresValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogValueMaxPresValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValueMaxPresValue) isBACnetConstructedDataAnalogValueMaxPresValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValueMaxPresValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
index 178dcc991c..e42d0c8fb5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogValuePresentValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogValuePresentValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValuePresentValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValuePresentValueExactly interface {
+ isBACnetConstructedDataAnalogValuePresentValue() bool
+}
+
// _BACnetConstructedDataAnalogValuePresentValue is the data-structure of this message
type _BACnetConstructedDataAnalogValuePresentValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogValuePresentValue) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValuePresentValue) isBACnetConstructedDataAnalogValuePresentValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValuePresentValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
index 96f67b9eef..1b85dc9b6d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAnalogValueRelinquishDefault interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAnalogValueRelinquishDefaultExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAnalogValueRelinquishDefault.
+// This is useful for switch cases.
+type BACnetConstructedDataAnalogValueRelinquishDefaultExactly interface {
+ isBACnetConstructedDataAnalogValueRelinquishDefault() bool
+}
+
// _BACnetConstructedDataAnalogValueRelinquishDefault is the data-structure of this message
type _BACnetConstructedDataAnalogValueRelinquishDefault struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAnalogValueRelinquishDefault) Serialize(writeBuff
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAnalogValueRelinquishDefault) isBACnetConstructedDataAnalogValueRelinquishDefault() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAnalogValueRelinquishDefault) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
index 0312a66395..abc20258b9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataApplicationSoftwareVersion interface {
GetActualValue() BACnetApplicationTagCharacterString
}
+// BACnetConstructedDataApplicationSoftwareVersionExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataApplicationSoftwareVersion.
+// This is useful for switch cases.
+type BACnetConstructedDataApplicationSoftwareVersionExactly interface {
+ isBACnetConstructedDataApplicationSoftwareVersion() bool
+}
+
// _BACnetConstructedDataApplicationSoftwareVersion is the data-structure of this message
type _BACnetConstructedDataApplicationSoftwareVersion struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataApplicationSoftwareVersion) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataApplicationSoftwareVersion) isBACnetConstructedDataApplicationSoftwareVersion() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataApplicationSoftwareVersion) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
index 1822e7ea6d..88881a9617 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataArchive interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataArchiveExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataArchive.
+// This is useful for switch cases.
+type BACnetConstructedDataArchiveExactly interface {
+ isBACnetConstructedDataArchive() bool
+}
+
// _BACnetConstructedDataArchive is the data-structure of this message
type _BACnetConstructedDataArchive struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataArchive) Serialize(writeBuffer utils.WriteBuffer)
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataArchive) isBACnetConstructedDataArchive() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataArchive) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedAccessRights.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedAccessRights.go
index aa764316e3..fe8b203b3f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedAccessRights.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedAccessRights.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAssignedAccessRights interface {
GetZero() uint64
}
+// BACnetConstructedDataAssignedAccessRightsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAssignedAccessRights.
+// This is useful for switch cases.
+type BACnetConstructedDataAssignedAccessRightsExactly interface {
+ isBACnetConstructedDataAssignedAccessRights() bool
+}
+
// _BACnetConstructedDataAssignedAccessRights is the data-structure of this message
type _BACnetConstructedDataAssignedAccessRights struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAssignedAccessRights) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAssignedAccessRights) isBACnetConstructedDataAssignedAccessRights() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAssignedAccessRights) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedLandingCalls.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedLandingCalls.go
index 560be9c02c..37d5822058 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedLandingCalls.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAssignedLandingCalls.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAssignedLandingCalls interface {
GetZero() uint64
}
+// BACnetConstructedDataAssignedLandingCallsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAssignedLandingCalls.
+// This is useful for switch cases.
+type BACnetConstructedDataAssignedLandingCallsExactly interface {
+ isBACnetConstructedDataAssignedLandingCalls() bool
+}
+
// _BACnetConstructedDataAssignedLandingCalls is the data-structure of this message
type _BACnetConstructedDataAssignedLandingCalls struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAssignedLandingCalls) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAssignedLandingCalls) isBACnetConstructedDataAssignedLandingCalls() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAssignedLandingCalls) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
index 2073ef85a6..1306f8317e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAttemptedSamples interface {
GetActualValue() BACnetApplicationTagUnsignedInteger
}
+// BACnetConstructedDataAttemptedSamplesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAttemptedSamples.
+// This is useful for switch cases.
+type BACnetConstructedDataAttemptedSamplesExactly interface {
+ isBACnetConstructedDataAttemptedSamples() bool
+}
+
// _BACnetConstructedDataAttemptedSamples is the data-structure of this message
type _BACnetConstructedDataAttemptedSamples struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAttemptedSamples) Serialize(writeBuffer utils.Wri
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAttemptedSamples) isBACnetConstructedDataAttemptedSamples() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAttemptedSamples) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationFactors.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationFactors.go
index 9d37627455..11517a3d66 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationFactors.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationFactors.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAuthenticationFactors interface {
GetZero() uint64
}
+// BACnetConstructedDataAuthenticationFactorsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthenticationFactors.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthenticationFactorsExactly interface {
+ isBACnetConstructedDataAuthenticationFactors() bool
+}
+
// _BACnetConstructedDataAuthenticationFactors is the data-structure of this message
type _BACnetConstructedDataAuthenticationFactors struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAuthenticationFactors) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthenticationFactors) isBACnetConstructedDataAuthenticationFactors() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthenticationFactors) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyList.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyList.go
index 40e5e7dbc7..26a8dda805 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyList.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyList.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAuthenticationPolicyList interface {
GetZero() uint64
}
+// BACnetConstructedDataAuthenticationPolicyListExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthenticationPolicyList.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthenticationPolicyListExactly interface {
+ isBACnetConstructedDataAuthenticationPolicyList() bool
+}
+
// _BACnetConstructedDataAuthenticationPolicyList is the data-structure of this message
type _BACnetConstructedDataAuthenticationPolicyList struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAuthenticationPolicyList) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthenticationPolicyList) isBACnetConstructedDataAuthenticationPolicyList() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthenticationPolicyList) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyNames.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyNames.go
index 25b8d3aac8..9f9a580d4b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyNames.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationPolicyNames.go
@@ -41,6 +41,12 @@ type BACnetConstructedDataAuthenticationPolicyNames interface {
GetZero() uint64
}
+// BACnetConstructedDataAuthenticationPolicyNamesExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthenticationPolicyNames.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthenticationPolicyNamesExactly interface {
+ isBACnetConstructedDataAuthenticationPolicyNames() bool
+}
+
// _BACnetConstructedDataAuthenticationPolicyNames is the data-structure of this message
type _BACnetConstructedDataAuthenticationPolicyNames struct {
*_BACnetConstructedData
@@ -289,6 +295,10 @@ func (m *_BACnetConstructedDataAuthenticationPolicyNames) Serialize(writeBuffer
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthenticationPolicyNames) isBACnetConstructedDataAuthenticationPolicyNames() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthenticationPolicyNames) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
index c43801c6ff..48e94a643d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAuthenticationStatus interface {
GetActualValue() BACnetAuthenticationStatusTagged
}
+// BACnetConstructedDataAuthenticationStatusExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthenticationStatus.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthenticationStatusExactly interface {
+ isBACnetConstructedDataAuthenticationStatus() bool
+}
+
// _BACnetConstructedDataAuthenticationStatus is the data-structure of this message
type _BACnetConstructedDataAuthenticationStatus struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAuthenticationStatus) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthenticationStatus) isBACnetConstructedDataAuthenticationStatus() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthenticationStatus) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationExemptions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationExemptions.go
index 7b3edb8956..cb287d5d52 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationExemptions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationExemptions.go
@@ -35,6 +35,12 @@ type BACnetConstructedDataAuthorizationExemptions interface {
GetAuthorizationExemption() []BACnetAuthorizationExemptionTagged
}
+// BACnetConstructedDataAuthorizationExemptionsExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthorizationExemptions.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthorizationExemptionsExactly interface {
+ isBACnetConstructedDataAuthorizationExemptions() bool
+}
+
// _BACnetConstructedDataAuthorizationExemptions is the data-structure of this message
type _BACnetConstructedDataAuthorizationExemptions struct {
*_BACnetConstructedData
@@ -207,6 +213,10 @@ func (m *_BACnetConstructedDataAuthorizationExemptions) Serialize(writeBuffer ut
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthorizationExemptions) isBACnetConstructedDataAuthorizationExemptions() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthorizationExemptions) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationMode.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationMode.go
index bd7dc0e34a..7bda51a694 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationMode.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthorizationMode.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAuthorizationMode interface {
GetActualValue() BACnetAuthorizationModeTagged
}
+// BACnetConstructedDataAuthorizationModeExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAuthorizationMode.
+// This is useful for switch cases.
+type BACnetConstructedDataAuthorizationModeExactly interface {
+ isBACnetConstructedDataAuthorizationMode() bool
+}
+
// _BACnetConstructedDataAuthorizationMode is the data-structure of this message
type _BACnetConstructedDataAuthorizationMode struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAuthorizationMode) Serialize(writeBuffer utils.Wr
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAuthorizationMode) isBACnetConstructedDataAuthorizationMode() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAuthorizationMode) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
index b8fdf2df73..0b94bd2ee2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAutoSlaveDiscovery interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataAutoSlaveDiscoveryExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAutoSlaveDiscovery.
+// This is useful for switch cases.
+type BACnetConstructedDataAutoSlaveDiscoveryExactly interface {
+ isBACnetConstructedDataAutoSlaveDiscovery() bool
+}
+
// _BACnetConstructedDataAutoSlaveDiscovery is the data-structure of this message
type _BACnetConstructedDataAutoSlaveDiscovery struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAutoSlaveDiscovery) Serialize(writeBuffer utils.W
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAutoSlaveDiscovery) isBACnetConstructedDataAutoSlaveDiscovery() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAutoSlaveDiscovery) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
index 553e8f487e..bce235edd6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataAverageValue interface {
GetActualValue() BACnetApplicationTagReal
}
+// BACnetConstructedDataAverageValueExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAverageValue.
+// This is useful for switch cases.
+type BACnetConstructedDataAverageValueExactly interface {
+ isBACnetConstructedDataAverageValue() bool
+}
+
// _BACnetConstructedDataAverageValue is the data-structure of this message
type _BACnetConstructedDataAverageValue struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataAverageValue) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAverageValue) isBACnetConstructedDataAverageValue() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAverageValue) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAveragingAll.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAveragingAll.go
index 947b1c0732..b4e92b538b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAveragingAll.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAveragingAll.go
@@ -33,6 +33,12 @@ type BACnetConstructedDataAveragingAll interface {
BACnetConstructedData
}
+// BACnetConstructedDataAveragingAllExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataAveragingAll.
+// This is useful for switch cases.
+type BACnetConstructedDataAveragingAllExactly interface {
+ isBACnetConstructedDataAveragingAll() bool
+}
+
// _BACnetConstructedDataAveragingAll is the data-structure of this message
type _BACnetConstructedDataAveragingAll struct {
*_BACnetConstructedData
@@ -150,6 +156,10 @@ func (m *_BACnetConstructedDataAveragingAll) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataAveragingAll) isBACnetConstructedDataAveragingAll() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataAveragingAll) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
index 743598777d..82178404a4 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataBACnetIPGlobalAddress interface {
GetActualValue() BACnetHostNPort
}
+// BACnetConstructedDataBACnetIPGlobalAddressExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataBACnetIPGlobalAddress.
+// This is useful for switch cases.
+type BACnetConstructedDataBACnetIPGlobalAddressExactly interface {
+ isBACnetConstructedDataBACnetIPGlobalAddress() bool
+}
+
// _BACnetConstructedDataBACnetIPGlobalAddress is the data-structure of this message
type _BACnetConstructedDataBACnetIPGlobalAddress struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataBACnetIPGlobalAddress) Serialize(writeBuffer util
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataBACnetIPGlobalAddress) isBACnetConstructedDataBACnetIPGlobalAddress() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataBACnetIPGlobalAddress) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
index 1279797828..c04d94a7df 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataBACnetIPMode interface {
GetActualValue() BACnetIPModeTagged
}
+// BACnetConstructedDataBACnetIPModeExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataBACnetIPMode.
+// This is useful for switch cases.
+type BACnetConstructedDataBACnetIPModeExactly interface {
+ isBACnetConstructedDataBACnetIPMode() bool
+}
+
// _BACnetConstructedDataBACnetIPMode is the data-structure of this message
type _BACnetConstructedDataBACnetIPMode struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataBACnetIPMode) Serialize(writeBuffer utils.WriteBu
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataBACnetIPMode) isBACnetConstructedDataBACnetIPMode() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataBACnetIPMode) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
index e1f5d3a856..67c2ab9a36 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataBACnetIPMulticastAddress interface {
GetActualValue() BACnetApplicationTagOctetString
}
+// BACnetConstructedDataBACnetIPMulticastAddressExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataBACnetIPMulticastAddress.
+// This is useful for switch cases.
+type BACnetConstructedDataBACnetIPMulticastAddressExactly interface {
+ isBACnetConstructedDataBACnetIPMulticastAddress() bool
+}
+
// _BACnetConstructedDataBACnetIPMulticastAddress is the data-structure of this message
type _BACnetConstructedDataBACnetIPMulticastAddress struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataBACnetIPMulticastAddress) Serialize(writeBuffer u
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataBACnetIPMulticastAddress) isBACnetConstructedDataBACnetIPMulticastAddress() bool {
+ return true
+}
+
func (m *_BACnetConstructedDataBACnetIPMulticastAddress) String() string {
if m == nil {
return "<nil>"
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
index e3398e0414..b8ada518c5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
@@ -37,6 +37,12 @@ type BACnetConstructedDataBACnetIPNATTraversal interface {
GetActualValue() BACnetApplicationTagBoolean
}
+// BACnetConstructedDataBACnetIPNATTraversalExactly can be used when we want exactly this type and not a type which fulfills BACnetConstructedDataBACnetIPNATTraversal.
+// This is useful for switch cases.
+type BACnetConstructedDataBACnetIPNATTraversalExactly interface {
+ isBACnetConstructedDataBACnetIPNATTraversal() bool
+}
+
// _BACnetConstructedDataBACnetIPNATTraversal is the data-structure of this message
type _BACnetConstructedDataBACnetIPNATTraversal struct {
*_BACnetConstructedData
@@ -218,6 +224,10 @@ func (m *_BACnetConstructedDataBACnetIPNATTraversal) Serialize(writeBuffer utils
return m.SerializeParent(writeBuffer, m, ser)
}
+func (m *_BACnetConstructedDataBACnetIPNATTraversal) isBACnetConstructedDataBACnetIPNATTraversal() bool {
+ return true
+}
+
... 44156 lines suppressed ...