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/14 12:56:54 UTC
[plc4x] branch develop updated: feat(bacnet): added accessors for constructed data types
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 27509709ff feat(bacnet): added accessors for constructed data types
27509709ff is described below
commit 27509709ff19b2acd20f3b4ced249fa22fb2bd57
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Jun 14 14:56:46 2022 +0200
feat(bacnet): added accessors for constructed data types
---
.../model/BACnetConstructedDataAPDULength.go | 26 +
.../BACnetConstructedDataAPDUSegmentTimeout.go | 26 +
.../model/BACnetConstructedDataAPDUTimeout.go | 26 +
.../model/BACnetConstructedDataAbsenteeLimit.go | 26 +
.../BACnetConstructedDataAccessDoorPresentValue.go | 26 +
...etConstructedDataAccessDoorRelinquishDefault.go | 26 +
.../model/BACnetConstructedDataAccessEvent.go | 26 +
...nstructedDataAccessEventAuthenticationFactor.go | 26 +
.../BACnetConstructedDataAccessEventCredential.go | 26 +
.../model/BACnetConstructedDataAccessEventTag.go | 26 +
.../model/BACnetConstructedDataAccessEventTime.go | 26 +
.../BACnetConstructedDataAccessZoneAdjustValue.go | 26 +
.../model/BACnetConstructedDataAccompaniment.go | 26 +
.../BACnetConstructedDataAccompanimentTime.go | 26 +
...CnetConstructedDataAccumulatorFaultHighLimit.go | 26 +
...ACnetConstructedDataAccumulatorFaultLowLimit.go | 26 +
.../BACnetConstructedDataAccumulatorHighLimit.go | 26 +
.../BACnetConstructedDataAccumulatorLowLimit.go | 26 +
...BACnetConstructedDataAccumulatorMaxPresValue.go | 26 +
...BACnetConstructedDataAccumulatorMinPresValue.go | 26 +
.../model/BACnetConstructedDataAckRequired.go | 26 +
.../model/BACnetConstructedDataAckedTransitions.go | 26 +
.../model/BACnetConstructedDataActivationTime.go | 26 +
...netConstructedDataActiveAuthenticationPolicy.go | 26 +
.../model/BACnetConstructedDataActiveText.go | 26 +
.../model/BACnetConstructedDataActualShedLevel.go | 26 +
.../model/BACnetConstructedDataAdjustValue.go | 26 +
.../model/BACnetConstructedDataAlarmValue.go | 26 +
...etConstructedDataAlertEnrollmentPresentValue.go | 26 +
.../model/BACnetConstructedDataAlignIntervals.go | 26 +
.../BACnetConstructedDataAllWritesSuccessful.go | 26 +
.../BACnetConstructedDataAllowGroupDelayInhibit.go | 26 +
...CnetConstructedDataAnalogInputFaultHighLimit.go | 26 +
...ACnetConstructedDataAnalogInputFaultLowLimit.go | 26 +
...CnetConstructedDataAnalogInputInterfaceValue.go | 26 +
...BACnetConstructedDataAnalogInputMaxPresValue.go | 26 +
...BACnetConstructedDataAnalogInputPresentValue.go | 26 +
...netConstructedDataAnalogOutputInterfaceValue.go | 26 +
...ACnetConstructedDataAnalogOutputMaxPresValue.go | 26 +
...ACnetConstructedDataAnalogOutputPresentValue.go | 26 +
...ConstructedDataAnalogOutputRelinquishDefault.go | 26 +
...CnetConstructedDataAnalogValueFaultHighLimit.go | 26 +
...ACnetConstructedDataAnalogValueFaultLowLimit.go | 26 +
...BACnetConstructedDataAnalogValueMaxPresValue.go | 26 +
...BACnetConstructedDataAnalogValuePresentValue.go | 26 +
...tConstructedDataAnalogValueRelinquishDefault.go | 26 +
...netConstructedDataApplicationSoftwareVersion.go | 26 +
.../model/BACnetConstructedDataArchive.go | 26 +
.../model/BACnetConstructedDataAttemptedSamples.go | 26 +
.../BACnetConstructedDataAuthenticationStatus.go | 26 +
.../BACnetConstructedDataAutoSlaveDiscovery.go | 26 +
.../model/BACnetConstructedDataAverageValue.go | 26 +
.../BACnetConstructedDataBACnetIPGlobalAddress.go | 26 +
.../model/BACnetConstructedDataBACnetIPMode.go | 26 +
...ACnetConstructedDataBACnetIPMulticastAddress.go | 26 +
.../BACnetConstructedDataBACnetIPNATTraversal.go | 26 +
.../model/BACnetConstructedDataBACnetIPUDPPort.go | 26 +
.../model/BACnetConstructedDataBACnetIPv6Mode.go | 26 +
...netConstructedDataBACnetIPv6MulticastAddress.go | 26 +
.../BACnetConstructedDataBACnetIPv6UDPPort.go | 26 +
...CnetConstructedDataBBMDAcceptFDRegistrations.go | 26 +
.../BACnetConstructedDataBackupAndRestoreState.go | 26 +
.../BACnetConstructedDataBackupFailureTimeout.go | 26 +
.../BACnetConstructedDataBackupPreparationTime.go | 26 +
...ACnetConstructedDataBaseDeviceSecurityPolicy.go | 26 +
.../model/BACnetConstructedDataBelongsTo.go | 26 +
.../readwrite/model/BACnetConstructedDataBias.go | 26 +
...CnetConstructedDataBinaryInputInterfaceValue.go | 26 +
...BACnetConstructedDataBinaryInputPresentValue.go | 26 +
...tructedDataBinaryLightingOutputFeedbackValue.go | 26 +
...structedDataBinaryLightingOutputPresentValue.go | 26 +
...tedDataBinaryLightingOutputRelinquishDefault.go | 26 +
...CnetConstructedDataBinaryOutputFeedbackValue.go | 26 +
...netConstructedDataBinaryOutputInterfaceValue.go | 26 +
...ACnetConstructedDataBinaryOutputPresentValue.go | 26 +
...ConstructedDataBinaryOutputRelinquishDefault.go | 26 +
...BACnetConstructedDataBinaryValuePresentValue.go | 26 +
...tConstructedDataBinaryValueRelinquishDefault.go | 26 +
.../model/BACnetConstructedDataBitMask.go | 26 +
...netConstructedDataBitStringValuePresentValue.go | 26 +
...nstructedDataBitStringValueRelinquishDefault.go | 26 +
.../model/BACnetConstructedDataBlinkWarnEnable.go | 26 +
.../model/BACnetConstructedDataBufferSize.go | 26 +
.../model/BACnetConstructedDataCOVIncrement.go | 26 +
.../model/BACnetConstructedDataCOVPeriod.go | 26 +
...CnetConstructedDataCOVResubscriptionInterval.go | 26 +
.../model/BACnetConstructedDataCOVUPeriod.go | 26 +
.../BACnetConstructedDataCalendarPresentValue.go | 26 +
.../BACnetConstructedDataCarAssignedDirection.go | 26 +
.../model/BACnetConstructedDataCarDoorZone.go | 26 +
.../model/BACnetConstructedDataCarDriveStatus.go | 26 +
.../model/BACnetConstructedDataCarLoad.go | 26 +
.../model/BACnetConstructedDataCarLoadUnits.go | 26 +
.../model/BACnetConstructedDataCarMode.go | 26 +
.../BACnetConstructedDataCarMovingDirection.go | 26 +
.../model/BACnetConstructedDataCarPosition.go | 26 +
.../BACnetConstructedDataChangeOfStateCount.go | 26 +
.../BACnetConstructedDataChangeOfStateTime.go | 26 +
.../model/BACnetConstructedDataChangesPending.go | 26 +
.../model/BACnetConstructedDataChannelNumber.go | 26 +
.../BACnetConstructedDataChannelPresentValue.go | 26 +
...structedDataCharacterStringValuePresentValue.go | 26 +
...tedDataCharacterStringValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataClientCOVIncrement.go | 26 +
.../model/BACnetConstructedDataCommand.go | 26 +
...etConstructedDataControlledVariableReference.go | 26 +
...BACnetConstructedDataControlledVariableUnits.go | 26 +
...BACnetConstructedDataControlledVariableValue.go | 26 +
.../readwrite/model/BACnetConstructedDataCount.go | 26 +
.../BACnetConstructedDataCountBeforeChange.go | 26 +
.../model/BACnetConstructedDataCountChangeTime.go | 26 +
...nstructedDataCredentialDataInputPresentValue.go | 26 +
...ConstructedDataCredentialDataInputUpdateTime.go | 26 +
.../BACnetConstructedDataCredentialDisable.go | 26 +
.../model/BACnetConstructedDataCredentialStatus.go | 26 +
.../BACnetConstructedDataCurrentCommandPriority.go | 26 +
.../model/BACnetConstructedDataDatabaseRevision.go | 26 +
...tConstructedDataDatePatternValuePresentValue.go | 26 +
...tructedDataDatePatternValueRelinquishDefault.go | 26 +
...structedDataDateTimePatternValuePresentValue.go | 26 +
...tedDataDateTimePatternValueRelinquishDefault.go | 26 +
...CnetConstructedDataDateTimeValuePresentValue.go | 26 +
...onstructedDataDateTimeValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataDateValuePresentValue.go | 26 +
...netConstructedDataDateValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataDaylightSavingsStatus.go | 26 +
.../model/BACnetConstructedDataDaysRemaining.go | 26 +
.../model/BACnetConstructedDataDeadband.go | 26 +
.../model/BACnetConstructedDataDefaultFadeTime.go | 26 +
.../model/BACnetConstructedDataDefaultRampRate.go | 26 +
.../BACnetConstructedDataDefaultStepIncrement.go | 26 +
...onstructedDataDefaultSubordinateRelationship.go | 26 +
.../model/BACnetConstructedDataDefaultTimeout.go | 26 +
...BACnetConstructedDataDeployedProfileLocation.go | 26 +
.../BACnetConstructedDataDerivativeConstant.go | 26 +
...BACnetConstructedDataDerivativeConstantUnits.go | 26 +
.../model/BACnetConstructedDataDescription.go | 26 +
.../BACnetConstructedDataDescriptionOfHalt.go | 26 +
.../BACnetConstructedDataDeviceMaxInfoFrames.go | 26 +
.../model/BACnetConstructedDataDeviceMaxMaster.go | 26 +
.../model/BACnetConstructedDataDeviceType.go | 26 +
.../model/BACnetConstructedDataDirectReading.go | 26 +
...BACnetConstructedDataDistributionKeyRevision.go | 26 +
.../model/BACnetConstructedDataDoNotHide.go | 26 +
.../model/BACnetConstructedDataDoorAlarmState.go | 26 +
.../BACnetConstructedDataDoorExtendedPulseTime.go | 26 +
.../BACnetConstructedDataDoorOpenTooLongTime.go | 26 +
.../model/BACnetConstructedDataDoorPulseTime.go | 26 +
.../model/BACnetConstructedDataDoorStatus.go | 26 +
.../BACnetConstructedDataDoorUnlockDelayTime.go | 26 +
.../model/BACnetConstructedDataDutyWindow.go | 26 +
.../model/BACnetConstructedDataEffectivePeriod.go | 26 +
.../model/BACnetConstructedDataEgressActive.go | 26 +
.../model/BACnetConstructedDataEgressTime.go | 26 +
.../BACnetConstructedDataElapsedActiveTime.go | 26 +
.../model/BACnetConstructedDataElevatorGroup.go | 26 +
.../readwrite/model/BACnetConstructedDataEnable.go | 26 +
.../model/BACnetConstructedDataEnergyMeter.go | 26 +
.../model/BACnetConstructedDataEnergyMeterRef.go | 26 +
.../model/BACnetConstructedDataErrorLimit.go | 26 +
.../model/BACnetConstructedDataEscalatorMode.go | 26 +
.../BACnetConstructedDataEventAlgorithmInhibit.go | 26 +
...ACnetConstructedDataEventAlgorithmInhibitRef.go | 26 +
.../BACnetConstructedDataEventDetectionEnable.go | 26 +
.../model/BACnetConstructedDataEventEnable.go | 26 +
.../model/BACnetConstructedDataEventParameters.go | 26 +
.../model/BACnetConstructedDataEventState.go | 26 +
.../model/BACnetConstructedDataEventType.go | 26 +
.../BACnetConstructedDataExpectedShedLevel.go | 26 +
.../model/BACnetConstructedDataExpirationTime.go | 26 +
.../BACnetConstructedDataExtendedTimeEnable.go | 26 +
.../model/BACnetConstructedDataFDBBMDAddress.go | 26 +
.../BACnetConstructedDataFDSubscriptionLifetime.go | 26 +
.../model/BACnetConstructedDataFailedAttempts.go | 26 +
.../BACnetConstructedDataFailedAttemptsTime.go | 26 +
.../model/BACnetConstructedDataFaultHighLimit.go | 26 +
.../model/BACnetConstructedDataFaultLowLimit.go | 26 +
.../model/BACnetConstructedDataFaultParameters.go | 26 +
.../model/BACnetConstructedDataFaultType.go | 26 +
.../model/BACnetConstructedDataFileAccessMethod.go | 26 +
.../model/BACnetConstructedDataFileRecordCount.go | 26 +
.../model/BACnetConstructedDataFileSize.go | 26 +
.../model/BACnetConstructedDataFileType.go | 26 +
.../model/BACnetConstructedDataFirmwareRevision.go | 26 +
.../model/BACnetConstructedDataFullDutyBaseline.go | 26 +
.../model/BACnetConstructedDataGlobalIdentifier.go | 26 +
.../model/BACnetConstructedDataGroupID.go | 26 +
.../model/BACnetConstructedDataGroupMode.go | 26 +
.../model/BACnetConstructedDataHighLimit.go | 26 +
.../model/BACnetConstructedDataHigherDeck.go | 26 +
.../model/BACnetConstructedDataIPAddress.go | 26 +
.../model/BACnetConstructedDataIPDHCPEnable.go | 26 +
.../model/BACnetConstructedDataIPDHCPLeaseTime.go | 26 +
...ACnetConstructedDataIPDHCPLeaseTimeRemaining.go | 26 +
.../model/BACnetConstructedDataIPDHCPServer.go | 26 +
.../model/BACnetConstructedDataIPDefaultGateway.go | 26 +
.../model/BACnetConstructedDataIPSubnetMask.go | 26 +
.../model/BACnetConstructedDataIPv6Address.go | 26 +
...ACnetConstructedDataIPv6AutoAddressingEnable.go | 26 +
.../BACnetConstructedDataIPv6DHCPLeaseTime.go | 26 +
...netConstructedDataIPv6DHCPLeaseTimeRemaining.go | 26 +
.../model/BACnetConstructedDataIPv6DHCPServer.go | 26 +
.../BACnetConstructedDataIPv6DefaultGateway.go | 26 +
.../model/BACnetConstructedDataIPv6PrefixLength.go | 26 +
.../model/BACnetConstructedDataIPv6ZoneIndex.go | 26 +
.../model/BACnetConstructedDataInProcess.go | 26 +
.../model/BACnetConstructedDataInProgress.go | 26 +
.../model/BACnetConstructedDataInactiveText.go | 26 +
.../model/BACnetConstructedDataInitialTimeout.go | 26 +
.../model/BACnetConstructedDataInputReference.go | 26 +
.../model/BACnetConstructedDataInstallationID.go | 26 +
.../model/BACnetConstructedDataInstanceOf.go | 26 +
.../BACnetConstructedDataInstantaneousPower.go | 26 +
...ACnetConstructedDataIntegerValueCOVIncrement.go | 26 +
.../BACnetConstructedDataIntegerValueDeadband.go | 26 +
...netConstructedDataIntegerValueFaultHighLimit.go | 26 +
...CnetConstructedDataIntegerValueFaultLowLimit.go | 26 +
.../BACnetConstructedDataIntegerValueHighLimit.go | 26 +
.../BACnetConstructedDataIntegerValueLowLimit.go | 26 +
...ACnetConstructedDataIntegerValueMaxPresValue.go | 26 +
...ACnetConstructedDataIntegerValueMinPresValue.go | 26 +
...ACnetConstructedDataIntegerValuePresentValue.go | 26 +
...ConstructedDataIntegerValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataIntegerValueResolution.go | 26 +
.../model/BACnetConstructedDataIntegralConstant.go | 26 +
.../BACnetConstructedDataIntegralConstantUnits.go | 26 +
.../model/BACnetConstructedDataIntervalOffset.go | 26 +
.../readwrite/model/BACnetConstructedDataIsUTC.go | 26 +
.../BACnetConstructedDataLandingCallControl.go | 26 +
...tConstructedDataLargeAnalogValueCOVIncrement.go | 26 +
...ACnetConstructedDataLargeAnalogValueDeadband.go | 26 +
...onstructedDataLargeAnalogValueFaultHighLimit.go | 26 +
...ConstructedDataLargeAnalogValueFaultLowLimit.go | 26 +
...CnetConstructedDataLargeAnalogValueHighLimit.go | 26 +
...ACnetConstructedDataLargeAnalogValueLowLimit.go | 26 +
...tConstructedDataLargeAnalogValueMaxPresValue.go | 26 +
...tConstructedDataLargeAnalogValueMinPresValue.go | 26 +
...tConstructedDataLargeAnalogValuePresentValue.go | 26 +
...tructedDataLargeAnalogValueRelinquishDefault.go | 26 +
...netConstructedDataLargeAnalogValueResolution.go | 26 +
.../model/BACnetConstructedDataLastAccessEvent.go | 26 +
.../model/BACnetConstructedDataLastAccessPoint.go | 26 +
.../model/BACnetConstructedDataLastCommandTime.go | 26 +
.../BACnetConstructedDataLastCredentialAdded.go | 26 +
...BACnetConstructedDataLastCredentialAddedTime.go | 26 +
.../BACnetConstructedDataLastCredentialRemoved.go | 26 +
...CnetConstructedDataLastCredentialRemovedTime.go | 26 +
.../model/BACnetConstructedDataLastKeyServer.go | 26 +
.../model/BACnetConstructedDataLastNotifyRecord.go | 26 +
.../model/BACnetConstructedDataLastPriority.go | 26 +
.../BACnetConstructedDataLastRestartReason.go | 26 +
.../model/BACnetConstructedDataLastRestoreTime.go | 26 +
.../model/BACnetConstructedDataLastStateChange.go | 26 +
.../model/BACnetConstructedDataLastUseTime.go | 26 +
...etConstructedDataLifeSafetyPointPresentValue.go | 26 +
...tructedDataLifeSafetyZoneMaintenanceRequired.go | 26 +
...netConstructedDataLifeSafetyZonePresentValue.go | 26 +
.../model/BACnetConstructedDataLightingCommand.go | 26 +
...onstructedDataLightingCommandDefaultPriority.go | 26 +
...etConstructedDataLightingOutputFeedbackValue.go | 26 +
...netConstructedDataLightingOutputPresentValue.go | 26 +
...nstructedDataLightingOutputRelinquishDefault.go | 26 +
...etConstructedDataLightingOutputTrackingValue.go | 26 +
.../model/BACnetConstructedDataLimitEnable.go | 26 +
...BACnetConstructedDataLimitMonitoringInterval.go | 26 +
.../model/BACnetConstructedDataLinkSpeed.go | 26 +
.../BACnetConstructedDataLinkSpeedAutonegotiate.go | 26 +
...BACnetConstructedDataLoadControlPresentValue.go | 26 +
.../model/BACnetConstructedDataLocalDate.go | 26 +
.../BACnetConstructedDataLocalForwardingOnly.go | 26 +
.../model/BACnetConstructedDataLocalTime.go | 26 +
.../model/BACnetConstructedDataLocation.go | 26 +
.../model/BACnetConstructedDataLockStatus.go | 26 +
.../model/BACnetConstructedDataLockout.go | 26 +
.../BACnetConstructedDataLockoutRelinquishTime.go | 26 +
...BACnetConstructedDataLogDeviceObjectProperty.go | 26 +
.../model/BACnetConstructedDataLogInterval.go | 26 +
.../model/BACnetConstructedDataLoggingObject.go | 26 +
.../model/BACnetConstructedDataLoggingRecord.go | 26 +
.../model/BACnetConstructedDataLoggingType.go | 26 +
.../model/BACnetConstructedDataLoopAction.go | 26 +
.../model/BACnetConstructedDataLoopPresentValue.go | 26 +
.../model/BACnetConstructedDataLowDiffLimit.go | 26 +
.../model/BACnetConstructedDataLowLimit.go | 26 +
.../model/BACnetConstructedDataLowerDeck.go | 26 +
.../model/BACnetConstructedDataMACAddress.go | 26 +
.../model/BACnetConstructedDataMachineRoomID.go | 26 +
.../BACnetConstructedDataMaintenanceRequired.go | 26 +
...tConstructedDataManipulatedVariableReference.go | 26 +
.../BACnetConstructedDataMaxAPDULengthAccepted.go | 26 +
.../model/BACnetConstructedDataMaxActualValue.go | 26 +
.../BACnetConstructedDataMaxFailedAttempts.go | 26 +
.../model/BACnetConstructedDataMaxInfoFrames.go | 26 +
.../model/BACnetConstructedDataMaxMaster.go | 26 +
.../model/BACnetConstructedDataMaxPresValue.go | 26 +
.../BACnetConstructedDataMaxSegmentsAccepted.go | 26 +
.../model/BACnetConstructedDataMaximumOutput.go | 26 +
.../model/BACnetConstructedDataMaximumValue.go | 26 +
.../BACnetConstructedDataMaximumValueTimestamp.go | 26 +
.../BACnetConstructedDataMemberStatusFlags.go | 26 +
.../model/BACnetConstructedDataMinActualValue.go | 26 +
.../model/BACnetConstructedDataMinPresValue.go | 26 +
.../model/BACnetConstructedDataMinimumOffTime.go | 26 +
.../model/BACnetConstructedDataMinimumOnTime.go | 26 +
.../model/BACnetConstructedDataMinimumOutput.go | 26 +
.../model/BACnetConstructedDataMinimumValue.go | 26 +
.../BACnetConstructedDataMinimumValueTimestamp.go | 26 +
.../readwrite/model/BACnetConstructedDataMode.go | 26 +
.../model/BACnetConstructedDataModelName.go | 26 +
.../model/BACnetConstructedDataModificationDate.go | 26 +
...ConstructedDataMultiStateInputInterfaceValue.go | 26 +
...ConstructedDataMultiStateOutputFeedbackValue.go | 26 +
...onstructedDataMultiStateOutputInterfaceValue.go | 26 +
...tructedDataMultiStateOutputRelinquishDefault.go | 26 +
...structedDataMultiStateValueRelinquishDefault.go | 26 +
.../model/BACnetConstructedDataMusterPoint.go | 26 +
.../BACnetConstructedDataNetworkInterfaceName.go | 26 +
.../model/BACnetConstructedDataNetworkNumber.go | 26 +
.../BACnetConstructedDataNetworkNumberQuality.go | 26 +
...ACnetConstructedDataNetworkPortMaxInfoFrames.go | 26 +
.../BACnetConstructedDataNetworkPortMaxMaster.go | 26 +
.../model/BACnetConstructedDataNetworkType.go | 26 +
.../BACnetConstructedDataNextStoppingFloor.go | 26 +
.../model/BACnetConstructedDataNodeSubtype.go | 26 +
.../model/BACnetConstructedDataNodeType.go | 26 +
.../BACnetConstructedDataNotificationClass.go | 26 +
.../BACnetConstructedDataNotificationThreshold.go | 26 +
.../model/BACnetConstructedDataNotifyType.go | 26 +
.../BACnetConstructedDataNumberOfAPDURetries.go | 26 +
...onstructedDataNumberOfAuthenticationPolicies.go | 26 +
.../model/BACnetConstructedDataNumberOfStates.go | 26 +
.../model/BACnetConstructedDataObjectIdentifier.go | 26 +
.../model/BACnetConstructedDataObjectName.go | 26 +
...BACnetConstructedDataObjectPropertyReference.go | 26 +
.../model/BACnetConstructedDataObjectType.go | 26 +
.../model/BACnetConstructedDataOccupancyCount.go | 26 +
.../BACnetConstructedDataOccupancyCountAdjust.go | 26 +
.../BACnetConstructedDataOccupancyCountEnable.go | 26 +
.../BACnetConstructedDataOccupancyLowerLimit.go | 26 +
...etConstructedDataOccupancyLowerLimitEnforced.go | 26 +
.../model/BACnetConstructedDataOccupancyState.go | 26 +
.../BACnetConstructedDataOccupancyUpperLimit.go | 26 +
...etConstructedDataOccupancyUpperLimitEnforced.go | 26 +
...tConstructedDataOctetStringValuePresentValue.go | 26 +
...tructedDataOctetStringValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataOperationDirection.go | 26 +
.../BACnetConstructedDataOperationExpected.go | 26 +
.../model/BACnetConstructedDataOutOfService.go | 26 +
.../model/BACnetConstructedDataOutputUnits.go | 26 +
.../BACnetConstructedDataPacketReorderTime.go | 26 +
.../model/BACnetConstructedDataPassbackMode.go | 26 +
.../model/BACnetConstructedDataPassbackTimeout.go | 26 +
.../model/BACnetConstructedDataPassengerAlarm.go | 26 +
.../model/BACnetConstructedDataPolarity.go | 26 +
...structedDataPositiveIntegerValueCOVIncrement.go | 26 +
...tConstructedDataPositiveIntegerValueDeadband.go | 26 +
...ructedDataPositiveIntegerValueFaultHighLimit.go | 26 +
...tructedDataPositiveIntegerValueFaultLowLimit.go | 26 +
...ConstructedDataPositiveIntegerValueHighLimit.go | 26 +
...tConstructedDataPositiveIntegerValueLowLimit.go | 26 +
...structedDataPositiveIntegerValueMaxPresValue.go | 26 +
...structedDataPositiveIntegerValueMinPresValue.go | 26 +
...tedDataPositiveIntegerValueRelinquishDefault.go | 26 +
...onstructedDataPositiveIntegerValueResolution.go | 26 +
.../readwrite/model/BACnetConstructedDataPower.go | 26 +
.../model/BACnetConstructedDataPowerMode.go | 26 +
.../model/BACnetConstructedDataPrescale.go | 26 +
.../model/BACnetConstructedDataPresentValue.go | 26 +
.../model/BACnetConstructedDataPriorityArray.go | 26 +
.../BACnetConstructedDataPriorityForWriting.go | 26 +
.../BACnetConstructedDataProcessIdentifier.go | 26 +
...BACnetConstructedDataProcessIdentifierFilter.go | 26 +
.../model/BACnetConstructedDataProfileLocation.go | 26 +
.../model/BACnetConstructedDataProfileName.go | 26 +
.../model/BACnetConstructedDataProgramChange.go | 26 +
.../model/BACnetConstructedDataProgramLocation.go | 26 +
.../model/BACnetConstructedDataProgramState.go | 26 +
.../BACnetConstructedDataProportionalConstant.go | 26 +
...CnetConstructedDataProportionalConstantUnits.go | 26 +
.../model/BACnetConstructedDataProtocolLevel.go | 26 +
...tConstructedDataProtocolObjectTypesSupported.go | 26 +
.../model/BACnetConstructedDataProtocolRevision.go | 26 +
...CnetConstructedDataProtocolServicesSupported.go | 26 +
.../model/BACnetConstructedDataProtocolVersion.go | 26 +
...CnetConstructedDataPulseConverterAdjustValue.go | 26 +
...netConstructedDataPulseConverterPresentValue.go | 26 +
.../model/BACnetConstructedDataPulseRate.go | 26 +
.../model/BACnetConstructedDataReadOnly.go | 26 +
.../model/BACnetConstructedDataReasonForHalt.go | 26 +
.../model/BACnetConstructedDataRecordCount.go | 26 +
...ACnetConstructedDataRecordsSinceNotification.go | 26 +
.../model/BACnetConstructedDataReferencePort.go | 26 +
.../model/BACnetConstructedDataReliability.go | 26 +
...tConstructedDataReliabilityEvaluationInhibit.go | 26 +
.../BACnetConstructedDataRelinquishDefault.go | 26 +
.../model/BACnetConstructedDataRepresents.go | 26 +
.../BACnetConstructedDataRequestedShedLevel.go | 26 +
...BACnetConstructedDataRequestedUpdateInterval.go | 26 +
.../model/BACnetConstructedDataResolution.go | 26 +
.../BACnetConstructedDataRestoreCompletionTime.go | 26 +
.../BACnetConstructedDataRestorePreparationTime.go | 26 +
.../readwrite/model/BACnetConstructedDataScale.go | 26 +
.../model/BACnetConstructedDataScaleFactor.go | 26 +
.../model/BACnetConstructedDataScheduleDefault.go | 26 +
.../BACnetConstructedDataSchedulePresentValue.go | 26 +
.../model/BACnetConstructedDataSecuredStatus.go | 26 +
.../BACnetConstructedDataSecurityPDUTimeout.go | 26 +
.../BACnetConstructedDataSecurityTimeWindow.go | 26 +
.../BACnetConstructedDataSegmentationSupported.go | 26 +
.../model/BACnetConstructedDataSerialNumber.go | 26 +
.../model/BACnetConstructedDataSetpoint.go | 26 +
.../BACnetConstructedDataSetpointReference.go | 26 +
.../model/BACnetConstructedDataSetting.go | 26 +
.../model/BACnetConstructedDataShedDuration.go | 26 +
.../model/BACnetConstructedDataSilenced.go | 26 +
.../model/BACnetConstructedDataSlaveProxyEnable.go | 26 +
.../model/BACnetConstructedDataStartTime.go | 26 +
.../model/BACnetConstructedDataStateDescription.go | 26 +
.../model/BACnetConstructedDataStatusFlags.go | 26 +
.../model/BACnetConstructedDataStopTime.go | 26 +
.../model/BACnetConstructedDataStopWhenFull.go | 26 +
.../model/BACnetConstructedDataStrikeCount.go | 26 +
.../model/BACnetConstructedDataSystemStatus.go | 26 +
.../model/BACnetConstructedDataThreatAuthority.go | 26 +
.../model/BACnetConstructedDataThreatLevel.go | 26 +
.../model/BACnetConstructedDataTimeDelay.go | 26 +
.../model/BACnetConstructedDataTimeDelayNormal.go | 26 +
.../BACnetConstructedDataTimeOfActiveTimeReset.go | 26 +
.../BACnetConstructedDataTimeOfDeviceRestart.go | 26 +
.../BACnetConstructedDataTimeOfStateCountReset.go | 26 +
.../BACnetConstructedDataTimeOfStrikeCountReset.go | 26 +
...tConstructedDataTimePatternValuePresentValue.go | 26 +
...tructedDataTimePatternValueRelinquishDefault.go | 26 +
...etConstructedDataTimeSynchronizationInterval.go | 26 +
.../BACnetConstructedDataTimeValuePresentValue.go | 26 +
...netConstructedDataTimeValueRelinquishDefault.go | 26 +
.../BACnetConstructedDataTimerMaxPresValue.go | 26 +
.../BACnetConstructedDataTimerMinPresValue.go | 26 +
.../model/BACnetConstructedDataTimerResolution.go | 26 +
.../model/BACnetConstructedDataTimerRunning.go | 26 +
.../model/BACnetConstructedDataTimerState.go | 26 +
.../model/BACnetConstructedDataTotalRecordCount.go | 26 +
.../model/BACnetConstructedDataTraceFlag.go | 26 +
.../model/BACnetConstructedDataTrackingValue.go | 26 +
...tConstructedDataTransactionNotificationClass.go | 26 +
.../model/BACnetConstructedDataTransition.go | 26 +
...nstructedDataTrendLogLogDeviceObjectProperty.go | 26 +
.../model/BACnetConstructedDataTrigger.go | 26 +
.../model/BACnetConstructedDataUTCOffset.go | 26 +
.../readwrite/model/BACnetConstructedDataUnits.go | 26 +
.../model/BACnetConstructedDataUpdateInterval.go | 26 +
.../BACnetConstructedDataUpdateKeySetTimeout.go | 26 +
.../model/BACnetConstructedDataUpdateTime.go | 26 +
.../BACnetConstructedDataUserExternalIdentifier.go | 26 +
...ACnetConstructedDataUserInformationReference.go | 26 +
.../model/BACnetConstructedDataUserName.go | 26 +
.../model/BACnetConstructedDataUserType.go | 26 +
.../model/BACnetConstructedDataUsesRemaining.go | 26 +
.../model/BACnetConstructedDataValidSamples.go | 26 +
.../BACnetConstructedDataValueBeforeChange.go | 26 +
.../model/BACnetConstructedDataValueChangeTime.go | 26 +
.../model/BACnetConstructedDataValueSet.go | 26 +
.../model/BACnetConstructedDataValueSource.go | 26 +
.../model/BACnetConstructedDataVarianceValue.go | 26 +
.../model/BACnetConstructedDataVendorIdentifier.go | 26 +
.../model/BACnetConstructedDataVendorName.go | 26 +
.../model/BACnetConstructedDataVerificationTime.go | 26 +
.../model/BACnetConstructedDataWindowInterval.go | 26 +
.../model/BACnetConstructedDataWindowSamples.go | 26 +
.../model/BACnetConstructedDataWriteStatus.go | 26 +
.../model/BACnetConstructedDataZoneFrom.go | 26 +
.../readwrite/model/BACnetConstructedDataZoneTo.go | 26 +
.../resources/protocols/bacnetip/bacnetip.mspec | 1375 +++++++++++++-------
473 files changed, 13195 insertions(+), 452 deletions(-)
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
index 24f8c18f2f..7ccd3a5bc7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDULength.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAPDULength interface {
IBACnetConstructedData
// GetApduLength returns ApduLength (property field)
GetApduLength() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAPDULength) GetApduLength() *BACnetApplicationTagU
return m.ApduLength
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAPDULength) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetApduLength())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAPDULength) GetLengthInBitsConditional(lastItem bo
// Simple field (apduLength)
lengthInBits += m.ApduLength.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAPDULengthParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for apduLength")
}
+ // Virtual field
+ _actualValue := apduLength
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAPDULength"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAPDULength")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAPDULength) Serialize(writeBuffer utils.WriteBuffe
if _apduLengthErr != nil {
return errors.Wrap(_apduLengthErr, "Error serializing 'apduLength' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAPDULength"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAPDULength")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
index b153e23aa5..dbe414b0ae 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUSegmentTimeout.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAPDUSegmentTimeout interface {
IBACnetConstructedData
// GetApduSegmentTimeout returns ApduSegmentTimeout (property field)
GetApduSegmentTimeout() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAPDUSegmentTimeout) GetApduSegmentTimeout() *BACne
return m.ApduSegmentTimeout
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAPDUSegmentTimeout) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetApduSegmentTimeout())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAPDUSegmentTimeout) GetLengthInBitsConditional(las
// Simple field (apduSegmentTimeout)
lengthInBits += m.ApduSegmentTimeout.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAPDUSegmentTimeoutParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for apduSegmentTimeout")
}
+ // Virtual field
+ _actualValue := apduSegmentTimeout
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAPDUSegmentTimeout"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAPDUSegmentTimeout")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAPDUSegmentTimeout) Serialize(writeBuffer utils.Wr
if _apduSegmentTimeoutErr != nil {
return errors.Wrap(_apduSegmentTimeoutErr, "Error serializing 'apduSegmentTimeout' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAPDUSegmentTimeout"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAPDUSegmentTimeout")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
index 3195e70bdd..40872644b4 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAPDUTimeout.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAPDUTimeout interface {
IBACnetConstructedData
// GetApduTimeout returns ApduTimeout (property field)
GetApduTimeout() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAPDUTimeout) GetApduTimeout() *BACnetApplicationTa
return m.ApduTimeout
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAPDUTimeout) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetApduTimeout())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAPDUTimeout) GetLengthInBitsConditional(lastItem b
// Simple field (apduTimeout)
lengthInBits += m.ApduTimeout.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAPDUTimeoutParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for apduTimeout")
}
+ // Virtual field
+ _actualValue := apduTimeout
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAPDUTimeout"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAPDUTimeout")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAPDUTimeout) Serialize(writeBuffer utils.WriteBuff
if _apduTimeoutErr != nil {
return errors.Wrap(_apduTimeoutErr, "Error serializing 'apduTimeout' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAPDUTimeout"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAPDUTimeout")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
index 3681548a81..125b3c5b94 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAbsenteeLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAbsenteeLimit interface {
IBACnetConstructedData
// GetAbsenteeLimit returns AbsenteeLimit (property field)
GetAbsenteeLimit() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAbsenteeLimit) GetAbsenteeLimit() *BACnetApplicati
return m.AbsenteeLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAbsenteeLimit) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetAbsenteeLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAbsenteeLimit) GetLengthInBitsConditional(lastItem
// Simple field (absenteeLimit)
lengthInBits += m.AbsenteeLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAbsenteeLimitParse(readBuffer utils.ReadBuffer, tagNum
return nil, errors.Wrap(closeErr, "Error closing for absenteeLimit")
}
+ // Virtual field
+ _actualValue := absenteeLimit
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAbsenteeLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAbsenteeLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAbsenteeLimit) Serialize(writeBuffer utils.WriteBu
if _absenteeLimitErr != nil {
return errors.Wrap(_absenteeLimitErr, "Error serializing 'absenteeLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAbsenteeLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAbsenteeLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
index 486553a561..e9944da26a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessDoorPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetDoorValueTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDoorValueTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessDoorPresentValue) GetPresentValue() *BACnetD
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessDoorPresentValue) GetActualValue() *BACnetDoorValueTagged {
+ return CastBACnetDoorValueTagged(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessDoorPresentValue) GetLengthInBitsConditional
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessDoorPresentValueParse(readBuffer utils.ReadBuffe
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetDoorValueTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessDoorPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessDoorPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessDoorPresentValue) Serialize(writeBuffer util
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessDoorPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessDoorPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
index d5a62f8481..453a8bf3bb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessDoorRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessDoorRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetDoorValueTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDoorValueTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessDoorRelinquishDefault) GetRelinquishDefault(
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessDoorRelinquishDefault) GetActualValue() *BACnetDoorValueTagged {
+ return CastBACnetDoorValueTagged(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessDoorRelinquishDefault) GetLengthInBitsCondit
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessDoorRelinquishDefaultParse(readBuffer utils.Read
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetDoorValueTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessDoorRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessDoorRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessDoorRelinquishDefault) Serialize(writeBuffer
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessDoorRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessDoorRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
index 93af740bfa..81967a3517 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEvent.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessEvent interface {
IBACnetConstructedData
// GetAccessEvent returns AccessEvent (property field)
GetAccessEvent() *BACnetAccessEventTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetAccessEventTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessEvent) GetAccessEvent() *BACnetAccessEventTa
return m.AccessEvent
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessEvent) GetActualValue() *BACnetAccessEventTagged {
+ return CastBACnetAccessEventTagged(m.GetAccessEvent())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessEvent) GetLengthInBitsConditional(lastItem b
// Simple field (accessEvent)
lengthInBits += m.AccessEvent.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessEventParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for accessEvent")
}
+ // Virtual field
+ _actualValue := accessEvent
+ actualValue := CastBACnetAccessEventTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessEvent"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessEvent")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessEvent) Serialize(writeBuffer utils.WriteBuff
if _accessEventErr != nil {
return errors.Wrap(_accessEventErr, "Error serializing 'accessEvent' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessEvent"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessEvent")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
index ab533399b2..1afeef175c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventAuthenticationFactor.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessEventAuthenticationFactor interface {
IBACnetConstructedData
// GetAccessEventAuthenticationFactor returns AccessEventAuthenticationFactor (property field)
GetAccessEventAuthenticationFactor() *BACnetAuthenticationFactor
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetAuthenticationFactor
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessEventAuthenticationFactor) GetAccessEventAut
return m.AccessEventAuthenticationFactor
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessEventAuthenticationFactor) GetActualValue() *BACnetAuthenticationFactor {
+ return CastBACnetAuthenticationFactor(m.GetAccessEventAuthenticationFactor())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessEventAuthenticationFactor) GetLengthInBitsCo
// Simple field (accessEventAuthenticationFactor)
lengthInBits += m.AccessEventAuthenticationFactor.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessEventAuthenticationFactorParse(readBuffer utils.
return nil, errors.Wrap(closeErr, "Error closing for accessEventAuthenticationFactor")
}
+ // Virtual field
+ _actualValue := accessEventAuthenticationFactor
+ actualValue := CastBACnetAuthenticationFactor(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessEventAuthenticationFactor"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessEventAuthenticationFactor")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessEventAuthenticationFactor) Serialize(writeBu
if _accessEventAuthenticationFactorErr != nil {
return errors.Wrap(_accessEventAuthenticationFactorErr, "Error serializing 'accessEventAuthenticationFactor' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessEventAuthenticationFactor"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessEventAuthenticationFactor")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
index f9687eba60..c930c60372 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventCredential.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessEventCredential interface {
IBACnetConstructedData
// GetAccessEventCredential returns AccessEventCredential (property field)
GetAccessEventCredential() *BACnetDeviceObjectReference
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDeviceObjectReference
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessEventCredential) GetAccessEventCredential()
return m.AccessEventCredential
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessEventCredential) GetActualValue() *BACnetDeviceObjectReference {
+ return CastBACnetDeviceObjectReference(m.GetAccessEventCredential())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessEventCredential) GetLengthInBitsConditional(
// Simple field (accessEventCredential)
lengthInBits += m.AccessEventCredential.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessEventCredentialParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for accessEventCredential")
}
+ // Virtual field
+ _actualValue := accessEventCredential
+ actualValue := CastBACnetDeviceObjectReference(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessEventCredential"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessEventCredential")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessEventCredential) Serialize(writeBuffer utils
if _accessEventCredentialErr != nil {
return errors.Wrap(_accessEventCredentialErr, "Error serializing 'accessEventCredential' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessEventCredential"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessEventCredential")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
index 4b3e385c75..d2ec1c27de 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTag.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessEventTag interface {
IBACnetConstructedData
// GetAccessEventTag returns AccessEventTag (property field)
GetAccessEventTag() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessEventTag) GetAccessEventTag() *BACnetApplica
return m.AccessEventTag
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessEventTag) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetAccessEventTag())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessEventTag) GetLengthInBitsConditional(lastIte
// Simple field (accessEventTag)
lengthInBits += m.AccessEventTag.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessEventTagParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for accessEventTag")
}
+ // Virtual field
+ _actualValue := accessEventTag
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessEventTag"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessEventTag")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessEventTag) Serialize(writeBuffer utils.WriteB
if _accessEventTagErr != nil {
return errors.Wrap(_accessEventTagErr, "Error serializing 'accessEventTag' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessEventTag"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessEventTag")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
index 4d2f2aabcd..7e344ba6ef 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessEventTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessEventTime interface {
IBACnetConstructedData
// GetAccessEventTime returns AccessEventTime (property field)
GetAccessEventTime() *BACnetTimeStamp
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetTimeStamp
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessEventTime) GetAccessEventTime() *BACnetTimeS
return m.AccessEventTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessEventTime) GetActualValue() *BACnetTimeStamp {
+ return CastBACnetTimeStamp(m.GetAccessEventTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessEventTime) GetLengthInBitsConditional(lastIt
// Simple field (accessEventTime)
lengthInBits += m.AccessEventTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessEventTimeParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for accessEventTime")
}
+ // Virtual field
+ _actualValue := accessEventTime
+ actualValue := CastBACnetTimeStamp(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessEventTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessEventTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessEventTime) Serialize(writeBuffer utils.Write
if _accessEventTimeErr != nil {
return errors.Wrap(_accessEventTimeErr, "Error serializing 'accessEventTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessEventTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessEventTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
index 7acde4d2d3..7ab474a290 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccessZoneAdjustValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccessZoneAdjustValue interface {
IBACnetConstructedData
// GetAdjustValue returns AdjustValue (property field)
GetAdjustValue() *BACnetApplicationTagSignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagSignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccessZoneAdjustValue) GetAdjustValue() *BACnetApp
return m.AdjustValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccessZoneAdjustValue) GetActualValue() *BACnetApplicationTagSignedInteger {
+ return CastBACnetApplicationTagSignedInteger(m.GetAdjustValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccessZoneAdjustValue) GetLengthInBitsConditional(
// Simple field (adjustValue)
lengthInBits += m.AdjustValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccessZoneAdjustValueParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for adjustValue")
}
+ // Virtual field
+ _actualValue := adjustValue
+ actualValue := CastBACnetApplicationTagSignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccessZoneAdjustValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccessZoneAdjustValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccessZoneAdjustValue) Serialize(writeBuffer utils
if _adjustValueErr != nil {
return errors.Wrap(_adjustValueErr, "Error serializing 'adjustValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccessZoneAdjustValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccessZoneAdjustValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
index 05dc67fee4..1282fbd961 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompaniment.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccompaniment interface {
IBACnetConstructedData
// GetAccompaniment returns Accompaniment (property field)
GetAccompaniment() *BACnetDeviceObjectReference
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDeviceObjectReference
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccompaniment) GetAccompaniment() *BACnetDeviceObj
return m.Accompaniment
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccompaniment) GetActualValue() *BACnetDeviceObjectReference {
+ return CastBACnetDeviceObjectReference(m.GetAccompaniment())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccompaniment) GetLengthInBitsConditional(lastItem
// Simple field (accompaniment)
lengthInBits += m.Accompaniment.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccompanimentParse(readBuffer utils.ReadBuffer, tagNum
return nil, errors.Wrap(closeErr, "Error closing for accompaniment")
}
+ // Virtual field
+ _actualValue := accompaniment
+ actualValue := CastBACnetDeviceObjectReference(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccompaniment"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccompaniment")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccompaniment) Serialize(writeBuffer utils.WriteBu
if _accompanimentErr != nil {
return errors.Wrap(_accompanimentErr, "Error serializing 'accompaniment' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccompaniment"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccompaniment")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
index 4733803fc0..7eafd930cd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccompanimentTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccompanimentTime interface {
IBACnetConstructedData
// GetAccompanimentTime returns AccompanimentTime (property field)
GetAccompanimentTime() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccompanimentTime) GetAccompanimentTime() *BACnetA
return m.AccompanimentTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccompanimentTime) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetAccompanimentTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccompanimentTime) GetLengthInBitsConditional(last
// Simple field (accompanimentTime)
lengthInBits += m.AccompanimentTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccompanimentTimeParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for accompanimentTime")
}
+ // Virtual field
+ _actualValue := accompanimentTime
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccompanimentTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccompanimentTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccompanimentTime) Serialize(writeBuffer utils.Wri
if _accompanimentTimeErr != nil {
return errors.Wrap(_accompanimentTimeErr, "Error serializing 'accompanimentTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccompanimentTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccompanimentTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
index 09bb801428..38507e4775 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultHighLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorFaultHighLimit interface {
IBACnetConstructedData
// GetFaultHighLimit returns FaultHighLimit (property field)
GetFaultHighLimit() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorFaultHighLimit) GetFaultHighLimit() *BA
return m.FaultHighLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorFaultHighLimit) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetFaultHighLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorFaultHighLimit) GetLengthInBitsConditio
// Simple field (faultHighLimit)
lengthInBits += m.FaultHighLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorFaultHighLimitParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for faultHighLimit")
}
+ // Virtual field
+ _actualValue := faultHighLimit
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorFaultHighLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorFaultHighLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorFaultHighLimit) Serialize(writeBuffer u
if _faultHighLimitErr != nil {
return errors.Wrap(_faultHighLimitErr, "Error serializing 'faultHighLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorFaultHighLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorFaultHighLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
index 072b809279..1a875047e1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorFaultLowLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorFaultLowLimit interface {
IBACnetConstructedData
// GetFaultLowLimit returns FaultLowLimit (property field)
GetFaultLowLimit() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorFaultLowLimit) GetFaultLowLimit() *BACn
return m.FaultLowLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorFaultLowLimit) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetFaultLowLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorFaultLowLimit) GetLengthInBitsCondition
// Simple field (faultLowLimit)
lengthInBits += m.FaultLowLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorFaultLowLimitParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for faultLowLimit")
}
+ // Virtual field
+ _actualValue := faultLowLimit
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorFaultLowLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorFaultLowLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorFaultLowLimit) Serialize(writeBuffer ut
if _faultLowLimitErr != nil {
return errors.Wrap(_faultLowLimitErr, "Error serializing 'faultLowLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorFaultLowLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorFaultLowLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
index fe8ca9e3c8..72abe9e451 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorHighLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorHighLimit interface {
IBACnetConstructedData
// GetHighLimit returns HighLimit (property field)
GetHighLimit() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorHighLimit) GetHighLimit() *BACnetApplic
return m.HighLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorHighLimit) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetHighLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorHighLimit) GetLengthInBitsConditional(l
// Simple field (highLimit)
lengthInBits += m.HighLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorHighLimitParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for highLimit")
}
+ // Virtual field
+ _actualValue := highLimit
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorHighLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorHighLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorHighLimit) Serialize(writeBuffer utils.
if _highLimitErr != nil {
return errors.Wrap(_highLimitErr, "Error serializing 'highLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorHighLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorHighLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
index 10e304ebf8..3361c8fb91 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorLowLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorLowLimit interface {
IBACnetConstructedData
// GetLowLimit returns LowLimit (property field)
GetLowLimit() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorLowLimit) GetLowLimit() *BACnetApplicat
return m.LowLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorLowLimit) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetLowLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorLowLimit) GetLengthInBitsConditional(la
// Simple field (lowLimit)
lengthInBits += m.LowLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorLowLimitParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for lowLimit")
}
+ // Virtual field
+ _actualValue := lowLimit
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorLowLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorLowLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorLowLimit) Serialize(writeBuffer utils.W
if _lowLimitErr != nil {
return errors.Wrap(_lowLimitErr, "Error serializing 'lowLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorLowLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorLowLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
index 6e56a6fe67..181a1d4dfb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMaxPresValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorMaxPresValue interface {
IBACnetConstructedData
// GetMaxPresValue returns MaxPresValue (property field)
GetMaxPresValue() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorMaxPresValue) GetMaxPresValue() *BACnet
return m.MaxPresValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorMaxPresValue) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetMaxPresValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorMaxPresValue) GetLengthInBitsConditiona
// Simple field (maxPresValue)
lengthInBits += m.MaxPresValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorMaxPresValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for maxPresValue")
}
+ // Virtual field
+ _actualValue := maxPresValue
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorMaxPresValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorMaxPresValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorMaxPresValue) Serialize(writeBuffer uti
if _maxPresValueErr != nil {
return errors.Wrap(_maxPresValueErr, "Error serializing 'maxPresValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorMaxPresValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorMaxPresValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
index d79dce0ac6..f480148849 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAccumulatorMinPresValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAccumulatorMinPresValue interface {
IBACnetConstructedData
// GetMinPresValue returns MinPresValue (property field)
GetMinPresValue() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAccumulatorMinPresValue) GetMinPresValue() *BACnet
return m.MinPresValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAccumulatorMinPresValue) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetMinPresValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAccumulatorMinPresValue) GetLengthInBitsConditiona
// Simple field (minPresValue)
lengthInBits += m.MinPresValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAccumulatorMinPresValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for minPresValue")
}
+ // Virtual field
+ _actualValue := minPresValue
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAccumulatorMinPresValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAccumulatorMinPresValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAccumulatorMinPresValue) Serialize(writeBuffer uti
if _minPresValueErr != nil {
return errors.Wrap(_minPresValueErr, "Error serializing 'minPresValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAccumulatorMinPresValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAccumulatorMinPresValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
index 2913351b22..30254ef074 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckRequired.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAckRequired interface {
IBACnetConstructedData
// GetAckRequired returns AckRequired (property field)
GetAckRequired() *BACnetEventTransitionBitsTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetEventTransitionBitsTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAckRequired) GetAckRequired() *BACnetEventTransiti
return m.AckRequired
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAckRequired) GetActualValue() *BACnetEventTransitionBitsTagged {
+ return CastBACnetEventTransitionBitsTagged(m.GetAckRequired())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAckRequired) GetLengthInBitsConditional(lastItem b
// Simple field (ackRequired)
lengthInBits += m.AckRequired.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAckRequiredParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for ackRequired")
}
+ // Virtual field
+ _actualValue := ackRequired
+ actualValue := CastBACnetEventTransitionBitsTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAckRequired"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAckRequired")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAckRequired) Serialize(writeBuffer utils.WriteBuff
if _ackRequiredErr != nil {
return errors.Wrap(_ackRequiredErr, "Error serializing 'ackRequired' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAckRequired"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAckRequired")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
index ff931c9229..11cc10c986 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAckedTransitions.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAckedTransitions interface {
IBACnetConstructedData
// GetAckedTransitions returns AckedTransitions (property field)
GetAckedTransitions() *BACnetEventTransitionBitsTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetEventTransitionBitsTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAckedTransitions) GetAckedTransitions() *BACnetEve
return m.AckedTransitions
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAckedTransitions) GetActualValue() *BACnetEventTransitionBitsTagged {
+ return CastBACnetEventTransitionBitsTagged(m.GetAckedTransitions())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAckedTransitions) GetLengthInBitsConditional(lastI
// Simple field (ackedTransitions)
lengthInBits += m.AckedTransitions.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAckedTransitionsParse(readBuffer utils.ReadBuffer, tag
return nil, errors.Wrap(closeErr, "Error closing for ackedTransitions")
}
+ // Virtual field
+ _actualValue := ackedTransitions
+ actualValue := CastBACnetEventTransitionBitsTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAckedTransitions"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAckedTransitions")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAckedTransitions) Serialize(writeBuffer utils.Writ
if _ackedTransitionsErr != nil {
return errors.Wrap(_ackedTransitionsErr, "Error serializing 'ackedTransitions' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAckedTransitions"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAckedTransitions")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
index cf5159d012..d9d85f64ad 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActivationTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataActivationTime interface {
IBACnetConstructedData
// GetActivationTime returns ActivationTime (property field)
GetActivationTime() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataActivationTime) GetActivationTime() *BACnetDateTim
return m.ActivationTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataActivationTime) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetActivationTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataActivationTime) GetLengthInBitsConditional(lastIte
// Simple field (activationTime)
lengthInBits += m.ActivationTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataActivationTimeParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for activationTime")
}
+ // Virtual field
+ _actualValue := activationTime
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataActivationTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataActivationTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataActivationTime) Serialize(writeBuffer utils.WriteB
if _activationTimeErr != nil {
return errors.Wrap(_activationTimeErr, "Error serializing 'activationTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataActivationTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataActivationTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
index 8ee92fc688..c424a959bb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveAuthenticationPolicy.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataActiveAuthenticationPolicy interface {
IBACnetConstructedData
// GetActiveAuthenticationPolicy returns ActiveAuthenticationPolicy (property field)
GetActiveAuthenticationPolicy() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataActiveAuthenticationPolicy) GetActiveAuthenticatio
return m.ActiveAuthenticationPolicy
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataActiveAuthenticationPolicy) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetActiveAuthenticationPolicy())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataActiveAuthenticationPolicy) GetLengthInBitsConditi
// Simple field (activeAuthenticationPolicy)
lengthInBits += m.ActiveAuthenticationPolicy.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataActiveAuthenticationPolicyParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for activeAuthenticationPolicy")
}
+ // Virtual field
+ _actualValue := activeAuthenticationPolicy
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataActiveAuthenticationPolicy"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataActiveAuthenticationPolicy")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataActiveAuthenticationPolicy) Serialize(writeBuffer
if _activeAuthenticationPolicyErr != nil {
return errors.Wrap(_activeAuthenticationPolicyErr, "Error serializing 'activeAuthenticationPolicy' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataActiveAuthenticationPolicy"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataActiveAuthenticationPolicy")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
index f5f640d16f..e892315000 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActiveText.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataActiveText interface {
IBACnetConstructedData
// GetActiveText returns ActiveText (property field)
GetActiveText() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataActiveText) GetActiveText() *BACnetApplicationTagC
return m.ActiveText
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataActiveText) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetActiveText())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataActiveText) GetLengthInBitsConditional(lastItem bo
// Simple field (activeText)
lengthInBits += m.ActiveText.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataActiveTextParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for activeText")
}
+ // Virtual field
+ _actualValue := activeText
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataActiveText"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataActiveText")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataActiveText) Serialize(writeBuffer utils.WriteBuffe
if _activeTextErr != nil {
return errors.Wrap(_activeTextErr, "Error serializing 'activeText' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataActiveText"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataActiveText")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
index 195693d42f..26abb7aa4b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataActualShedLevel.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataActualShedLevel interface {
IBACnetConstructedData
// GetActualShedLevel returns ActualShedLevel (property field)
GetActualShedLevel() *BACnetShedLevel
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetShedLevel
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataActualShedLevel) GetActualShedLevel() *BACnetShedL
return m.ActualShedLevel
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataActualShedLevel) GetActualValue() *BACnetShedLevel {
+ return CastBACnetShedLevel(m.GetActualShedLevel())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataActualShedLevel) GetLengthInBitsConditional(lastIt
// Simple field (actualShedLevel)
lengthInBits += m.ActualShedLevel.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataActualShedLevelParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for actualShedLevel")
}
+ // Virtual field
+ _actualValue := actualShedLevel
+ actualValue := CastBACnetShedLevel(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataActualShedLevel"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataActualShedLevel")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataActualShedLevel) Serialize(writeBuffer utils.Write
if _actualShedLevelErr != nil {
return errors.Wrap(_actualShedLevelErr, "Error serializing 'actualShedLevel' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataActualShedLevel"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataActualShedLevel")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
index 73e33da0b6..da6936554c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAdjustValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAdjustValue interface {
IBACnetConstructedData
// GetAdjustValue returns AdjustValue (property field)
GetAdjustValue() *BACnetApplicationTagSignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagSignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAdjustValue) GetAdjustValue() *BACnetApplicationTa
return m.AdjustValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAdjustValue) GetActualValue() *BACnetApplicationTagSignedInteger {
+ return CastBACnetApplicationTagSignedInteger(m.GetAdjustValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAdjustValue) GetLengthInBitsConditional(lastItem b
// Simple field (adjustValue)
lengthInBits += m.AdjustValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAdjustValueParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for adjustValue")
}
+ // Virtual field
+ _actualValue := adjustValue
+ actualValue := CastBACnetApplicationTagSignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAdjustValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAdjustValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAdjustValue) Serialize(writeBuffer utils.WriteBuff
if _adjustValueErr != nil {
return errors.Wrap(_adjustValueErr, "Error serializing 'adjustValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAdjustValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAdjustValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
index c71319aa8a..aecd0cdb30 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlarmValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAlarmValue interface {
IBACnetConstructedData
// GetBinaryPv returns BinaryPv (property field)
GetBinaryPv() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAlarmValue) GetBinaryPv() *BACnetBinaryPVTagged {
return m.BinaryPv
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAlarmValue) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetBinaryPv())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAlarmValue) GetLengthInBitsConditional(lastItem bo
// Simple field (binaryPv)
lengthInBits += m.BinaryPv.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAlarmValueParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for binaryPv")
}
+ // Virtual field
+ _actualValue := binaryPv
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAlarmValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAlarmValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAlarmValue) Serialize(writeBuffer utils.WriteBuffe
if _binaryPvErr != nil {
return errors.Wrap(_binaryPvErr, "Error serializing 'binaryPv' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAlarmValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAlarmValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
index bc4a797b87..d4eb6c8953 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlertEnrollmentPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAlertEnrollmentPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagObjectIdentifier
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagObjectIdentifier
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAlertEnrollmentPresentValue) GetPresentValue() *BA
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAlertEnrollmentPresentValue) GetActualValue() *BACnetApplicationTagObjectIdentifier {
+ return CastBACnetApplicationTagObjectIdentifier(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAlertEnrollmentPresentValue) GetLengthInBitsCondit
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAlertEnrollmentPresentValueParse(readBuffer utils.Read
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagObjectIdentifier(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAlertEnrollmentPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAlertEnrollmentPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAlertEnrollmentPresentValue) Serialize(writeBuffer
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAlertEnrollmentPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAlertEnrollmentPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
index bdefa52c70..ee4ea62746 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAlignIntervals.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAlignIntervals interface {
IBACnetConstructedData
// GetAlignIntervals returns AlignIntervals (property field)
GetAlignIntervals() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAlignIntervals) GetAlignIntervals() *BACnetApplica
return m.AlignIntervals
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAlignIntervals) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetAlignIntervals())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAlignIntervals) GetLengthInBitsConditional(lastIte
// Simple field (alignIntervals)
lengthInBits += m.AlignIntervals.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAlignIntervalsParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for alignIntervals")
}
+ // Virtual field
+ _actualValue := alignIntervals
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAlignIntervals"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAlignIntervals")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAlignIntervals) Serialize(writeBuffer utils.WriteB
if _alignIntervalsErr != nil {
return errors.Wrap(_alignIntervalsErr, "Error serializing 'alignIntervals' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAlignIntervals"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAlignIntervals")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
index b3fca8fb34..ffa76d5424 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllWritesSuccessful.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAllWritesSuccessful interface {
IBACnetConstructedData
// GetAllWritesSuccessful returns AllWritesSuccessful (property field)
GetAllWritesSuccessful() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAllWritesSuccessful) GetAllWritesSuccessful() *BAC
return m.AllWritesSuccessful
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAllWritesSuccessful) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetAllWritesSuccessful())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAllWritesSuccessful) GetLengthInBitsConditional(la
// Simple field (allWritesSuccessful)
lengthInBits += m.AllWritesSuccessful.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAllWritesSuccessfulParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for allWritesSuccessful")
}
+ // Virtual field
+ _actualValue := allWritesSuccessful
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAllWritesSuccessful"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAllWritesSuccessful")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAllWritesSuccessful) Serialize(writeBuffer utils.W
if _allWritesSuccessfulErr != nil {
return errors.Wrap(_allWritesSuccessfulErr, "Error serializing 'allWritesSuccessful' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAllWritesSuccessful"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAllWritesSuccessful")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
index 0e0774ae1f..c014292960 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAllowGroupDelayInhibit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAllowGroupDelayInhibit interface {
IBACnetConstructedData
// GetAllowGroupDelayInhibit returns AllowGroupDelayInhibit (property field)
GetAllowGroupDelayInhibit() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAllowGroupDelayInhibit) GetAllowGroupDelayInhibit(
return m.AllowGroupDelayInhibit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAllowGroupDelayInhibit) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetAllowGroupDelayInhibit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAllowGroupDelayInhibit) GetLengthInBitsConditional
// Simple field (allowGroupDelayInhibit)
lengthInBits += m.AllowGroupDelayInhibit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAllowGroupDelayInhibitParse(readBuffer utils.ReadBuffe
return nil, errors.Wrap(closeErr, "Error closing for allowGroupDelayInhibit")
}
+ // Virtual field
+ _actualValue := allowGroupDelayInhibit
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAllowGroupDelayInhibit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAllowGroupDelayInhibit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAllowGroupDelayInhibit) Serialize(writeBuffer util
if _allowGroupDelayInhibitErr != nil {
return errors.Wrap(_allowGroupDelayInhibitErr, "Error serializing 'allowGroupDelayInhibit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAllowGroupDelayInhibit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAllowGroupDelayInhibit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
index 95ad0d9e45..9f06efb278 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultHighLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogInputFaultHighLimit interface {
IBACnetConstructedData
// GetFaultHighLimit returns FaultHighLimit (property field)
GetFaultHighLimit() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogInputFaultHighLimit) GetFaultHighLimit() *BA
return m.FaultHighLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogInputFaultHighLimit) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetFaultHighLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogInputFaultHighLimit) GetLengthInBitsConditio
// Simple field (faultHighLimit)
lengthInBits += m.FaultHighLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogInputFaultHighLimitParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for faultHighLimit")
}
+ // Virtual field
+ _actualValue := faultHighLimit
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogInputFaultHighLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogInputFaultHighLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogInputFaultHighLimit) Serialize(writeBuffer u
if _faultHighLimitErr != nil {
return errors.Wrap(_faultHighLimitErr, "Error serializing 'faultHighLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogInputFaultHighLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogInputFaultHighLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
index ffc0cd15b7..7509cd8fbc 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputFaultLowLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogInputFaultLowLimit interface {
IBACnetConstructedData
// GetFaultLowLimit returns FaultLowLimit (property field)
GetFaultLowLimit() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogInputFaultLowLimit) GetFaultLowLimit() *BACn
return m.FaultLowLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogInputFaultLowLimit) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetFaultLowLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogInputFaultLowLimit) GetLengthInBitsCondition
// Simple field (faultLowLimit)
lengthInBits += m.FaultLowLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogInputFaultLowLimitParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for faultLowLimit")
}
+ // Virtual field
+ _actualValue := faultLowLimit
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogInputFaultLowLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogInputFaultLowLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogInputFaultLowLimit) Serialize(writeBuffer ut
if _faultLowLimitErr != nil {
return errors.Wrap(_faultLowLimitErr, "Error serializing 'faultLowLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogInputFaultLowLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogInputFaultLowLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
index 3e086ac313..10f3056471 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputInterfaceValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogInputInterfaceValue interface {
IBACnetConstructedData
// GetInterfaceValue returns InterfaceValue (property field)
GetInterfaceValue() *BACnetOptionalREAL
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetOptionalREAL
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogInputInterfaceValue) GetInterfaceValue() *BA
return m.InterfaceValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogInputInterfaceValue) GetActualValue() *BACnetOptionalREAL {
+ return CastBACnetOptionalREAL(m.GetInterfaceValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogInputInterfaceValue) GetLengthInBitsConditio
// Simple field (interfaceValue)
lengthInBits += m.InterfaceValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogInputInterfaceValueParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for interfaceValue")
}
+ // Virtual field
+ _actualValue := interfaceValue
+ actualValue := CastBACnetOptionalREAL(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogInputInterfaceValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogInputInterfaceValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogInputInterfaceValue) Serialize(writeBuffer u
if _interfaceValueErr != nil {
return errors.Wrap(_interfaceValueErr, "Error serializing 'interfaceValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogInputInterfaceValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogInputInterfaceValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
index b6d412f8ee..d9a7bc4922 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputMaxPresValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogInputMaxPresValue interface {
IBACnetConstructedData
// GetMaxPresValue returns MaxPresValue (property field)
GetMaxPresValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogInputMaxPresValue) GetMaxPresValue() *BACnet
return m.MaxPresValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogInputMaxPresValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetMaxPresValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogInputMaxPresValue) GetLengthInBitsConditiona
// Simple field (maxPresValue)
lengthInBits += m.MaxPresValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogInputMaxPresValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for maxPresValue")
}
+ // Virtual field
+ _actualValue := maxPresValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogInputMaxPresValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogInputMaxPresValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogInputMaxPresValue) Serialize(writeBuffer uti
if _maxPresValueErr != nil {
return errors.Wrap(_maxPresValueErr, "Error serializing 'maxPresValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogInputMaxPresValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogInputMaxPresValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
index 262d82f441..de0c028829 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogInputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogInputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogInputPresentValue) GetPresentValue() *BACnet
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogInputPresentValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogInputPresentValue) GetLengthInBitsConditiona
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogInputPresentValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogInputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogInputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogInputPresentValue) Serialize(writeBuffer uti
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogInputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogInputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
index 9621e2b092..dea60ce214 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputInterfaceValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogOutputInterfaceValue interface {
IBACnetConstructedData
// GetInterfaceValue returns InterfaceValue (property field)
GetInterfaceValue() *BACnetOptionalREAL
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetOptionalREAL
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogOutputInterfaceValue) GetInterfaceValue() *B
return m.InterfaceValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogOutputInterfaceValue) GetActualValue() *BACnetOptionalREAL {
+ return CastBACnetOptionalREAL(m.GetInterfaceValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogOutputInterfaceValue) GetLengthInBitsConditi
// Simple field (interfaceValue)
lengthInBits += m.InterfaceValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogOutputInterfaceValueParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for interfaceValue")
}
+ // Virtual field
+ _actualValue := interfaceValue
+ actualValue := CastBACnetOptionalREAL(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogOutputInterfaceValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogOutputInterfaceValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogOutputInterfaceValue) Serialize(writeBuffer
if _interfaceValueErr != nil {
return errors.Wrap(_interfaceValueErr, "Error serializing 'interfaceValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogOutputInterfaceValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogOutputInterfaceValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
index f02f509be0..6fec78a5ec 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputMaxPresValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogOutputMaxPresValue interface {
IBACnetConstructedData
// GetMaxPresValue returns MaxPresValue (property field)
GetMaxPresValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogOutputMaxPresValue) GetMaxPresValue() *BACne
return m.MaxPresValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogOutputMaxPresValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetMaxPresValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogOutputMaxPresValue) GetLengthInBitsCondition
// Simple field (maxPresValue)
lengthInBits += m.MaxPresValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogOutputMaxPresValueParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for maxPresValue")
}
+ // Virtual field
+ _actualValue := maxPresValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogOutputMaxPresValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogOutputMaxPresValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogOutputMaxPresValue) Serialize(writeBuffer ut
if _maxPresValueErr != nil {
return errors.Wrap(_maxPresValueErr, "Error serializing 'maxPresValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogOutputMaxPresValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogOutputMaxPresValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
index 8499e4eaa2..58207a22ec 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogOutputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogOutputPresentValue) GetPresentValue() *BACne
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogOutputPresentValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogOutputPresentValue) GetLengthInBitsCondition
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogOutputPresentValueParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogOutputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogOutputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogOutputPresentValue) Serialize(writeBuffer ut
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogOutputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogOutputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
index cddf30ce14..47f2501a07 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogOutputRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogOutputRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogOutputRelinquishDefault) GetRelinquishDefaul
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogOutputRelinquishDefault) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogOutputRelinquishDefault) GetLengthInBitsCond
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogOutputRelinquishDefaultParse(readBuffer utils.Re
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogOutputRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogOutputRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogOutputRelinquishDefault) Serialize(writeBuff
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogOutputRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogOutputRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
index ffa6f07ada..83c6aebef2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultHighLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogValueFaultHighLimit interface {
IBACnetConstructedData
// GetFaultHighLimit returns FaultHighLimit (property field)
GetFaultHighLimit() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogValueFaultHighLimit) GetFaultHighLimit() *BA
return m.FaultHighLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogValueFaultHighLimit) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetFaultHighLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogValueFaultHighLimit) GetLengthInBitsConditio
// Simple field (faultHighLimit)
lengthInBits += m.FaultHighLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogValueFaultHighLimitParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for faultHighLimit")
}
+ // Virtual field
+ _actualValue := faultHighLimit
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogValueFaultHighLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogValueFaultHighLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogValueFaultHighLimit) Serialize(writeBuffer u
if _faultHighLimitErr != nil {
return errors.Wrap(_faultHighLimitErr, "Error serializing 'faultHighLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogValueFaultHighLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogValueFaultHighLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
index f769290455..9467a9bd39 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueFaultLowLimit.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogValueFaultLowLimit interface {
IBACnetConstructedData
// GetFaultLowLimit returns FaultLowLimit (property field)
GetFaultLowLimit() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogValueFaultLowLimit) GetFaultLowLimit() *BACn
return m.FaultLowLimit
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogValueFaultLowLimit) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetFaultLowLimit())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogValueFaultLowLimit) GetLengthInBitsCondition
// Simple field (faultLowLimit)
lengthInBits += m.FaultLowLimit.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogValueFaultLowLimitParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for faultLowLimit")
}
+ // Virtual field
+ _actualValue := faultLowLimit
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogValueFaultLowLimit"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogValueFaultLowLimit")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogValueFaultLowLimit) Serialize(writeBuffer ut
if _faultLowLimitErr != nil {
return errors.Wrap(_faultLowLimitErr, "Error serializing 'faultLowLimit' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogValueFaultLowLimit"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogValueFaultLowLimit")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
index b15ce412e2..daa0b35c01 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueMaxPresValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogValueMaxPresValue interface {
IBACnetConstructedData
// GetMaxPresValue returns MaxPresValue (property field)
GetMaxPresValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogValueMaxPresValue) GetMaxPresValue() *BACnet
return m.MaxPresValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogValueMaxPresValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetMaxPresValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogValueMaxPresValue) GetLengthInBitsConditiona
// Simple field (maxPresValue)
lengthInBits += m.MaxPresValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogValueMaxPresValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for maxPresValue")
}
+ // Virtual field
+ _actualValue := maxPresValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogValueMaxPresValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogValueMaxPresValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogValueMaxPresValue) Serialize(writeBuffer uti
if _maxPresValueErr != nil {
return errors.Wrap(_maxPresValueErr, "Error serializing 'maxPresValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogValueMaxPresValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogValueMaxPresValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
index 74e7fa165e..52c705f3dd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogValuePresentValue) GetPresentValue() *BACnet
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogValuePresentValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogValuePresentValue) GetLengthInBitsConditiona
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogValuePresentValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogValuePresentValue) Serialize(writeBuffer uti
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
index 1f6074cee5..ae83906b83 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAnalogValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAnalogValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAnalogValueRelinquishDefault) GetRelinquishDefault
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAnalogValueRelinquishDefault) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAnalogValueRelinquishDefault) GetLengthInBitsCondi
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAnalogValueRelinquishDefaultParse(readBuffer utils.Rea
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAnalogValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAnalogValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAnalogValueRelinquishDefault) Serialize(writeBuffe
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAnalogValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAnalogValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
index 2c1e6711eb..77028d4e7f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataApplicationSoftwareVersion.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataApplicationSoftwareVersion interface {
IBACnetConstructedData
// GetApplicationSoftwareVersion returns ApplicationSoftwareVersion (property field)
GetApplicationSoftwareVersion() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataApplicationSoftwareVersion) GetApplicationSoftware
return m.ApplicationSoftwareVersion
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataApplicationSoftwareVersion) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetApplicationSoftwareVersion())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataApplicationSoftwareVersion) GetLengthInBitsConditi
// Simple field (applicationSoftwareVersion)
lengthInBits += m.ApplicationSoftwareVersion.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataApplicationSoftwareVersionParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for applicationSoftwareVersion")
}
+ // Virtual field
+ _actualValue := applicationSoftwareVersion
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataApplicationSoftwareVersion"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataApplicationSoftwareVersion")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataApplicationSoftwareVersion) Serialize(writeBuffer
if _applicationSoftwareVersionErr != nil {
return errors.Wrap(_applicationSoftwareVersionErr, "Error serializing 'applicationSoftwareVersion' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataApplicationSoftwareVersion"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataApplicationSoftwareVersion")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
index d3331d5904..b2bf2c5b55 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataArchive.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataArchive interface {
IBACnetConstructedData
// GetArchive returns Archive (property field)
GetArchive() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataArchive) GetArchive() *BACnetApplicationTagBoolean
return m.Archive
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataArchive) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetArchive())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataArchive) GetLengthInBitsConditional(lastItem bool)
// Simple field (archive)
lengthInBits += m.Archive.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataArchiveParse(readBuffer utils.ReadBuffer, tagNumber ui
return nil, errors.Wrap(closeErr, "Error closing for archive")
}
+ // Virtual field
+ _actualValue := archive
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataArchive"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataArchive")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataArchive) Serialize(writeBuffer utils.WriteBuffer)
if _archiveErr != nil {
return errors.Wrap(_archiveErr, "Error serializing 'archive' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataArchive"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataArchive")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
index c68906e2c3..cdace2acf8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAttemptedSamples interface {
IBACnetConstructedData
// GetAttemptedSamples returns AttemptedSamples (property field)
GetAttemptedSamples() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAttemptedSamples) GetAttemptedSamples() *BACnetApp
return m.AttemptedSamples
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAttemptedSamples) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetAttemptedSamples())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAttemptedSamples) GetLengthInBitsConditional(lastI
// Simple field (attemptedSamples)
lengthInBits += m.AttemptedSamples.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAttemptedSamplesParse(readBuffer utils.ReadBuffer, tag
return nil, errors.Wrap(closeErr, "Error closing for attemptedSamples")
}
+ // Virtual field
+ _actualValue := attemptedSamples
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAttemptedSamples"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAttemptedSamples")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAttemptedSamples) Serialize(writeBuffer utils.Writ
if _attemptedSamplesErr != nil {
return errors.Wrap(_attemptedSamplesErr, "Error serializing 'attemptedSamples' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAttemptedSamples"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAttemptedSamples")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
index cd623902b1..9a6fd0c35c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAuthenticationStatus.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAuthenticationStatus interface {
IBACnetConstructedData
// GetAuthenticationStatus returns AuthenticationStatus (property field)
GetAuthenticationStatus() *BACnetAuthenticationStatusTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetAuthenticationStatusTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAuthenticationStatus) GetAuthenticationStatus() *B
return m.AuthenticationStatus
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAuthenticationStatus) GetActualValue() *BACnetAuthenticationStatusTagged {
+ return CastBACnetAuthenticationStatusTagged(m.GetAuthenticationStatus())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAuthenticationStatus) GetLengthInBitsConditional(l
// Simple field (authenticationStatus)
lengthInBits += m.AuthenticationStatus.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAuthenticationStatusParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for authenticationStatus")
}
+ // Virtual field
+ _actualValue := authenticationStatus
+ actualValue := CastBACnetAuthenticationStatusTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAuthenticationStatus"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAuthenticationStatus")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAuthenticationStatus) Serialize(writeBuffer utils.
if _authenticationStatusErr != nil {
return errors.Wrap(_authenticationStatusErr, "Error serializing 'authenticationStatus' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAuthenticationStatus"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAuthenticationStatus")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
index a14a94c70a..cfc830b0a9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAutoSlaveDiscovery.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAutoSlaveDiscovery interface {
IBACnetConstructedData
// GetAutoSlaveDiscovery returns AutoSlaveDiscovery (property field)
GetAutoSlaveDiscovery() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAutoSlaveDiscovery) GetAutoSlaveDiscovery() *BACne
return m.AutoSlaveDiscovery
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAutoSlaveDiscovery) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetAutoSlaveDiscovery())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAutoSlaveDiscovery) GetLengthInBitsConditional(las
// Simple field (autoSlaveDiscovery)
lengthInBits += m.AutoSlaveDiscovery.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAutoSlaveDiscoveryParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for autoSlaveDiscovery")
}
+ // Virtual field
+ _actualValue := autoSlaveDiscovery
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAutoSlaveDiscovery"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAutoSlaveDiscovery")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAutoSlaveDiscovery) Serialize(writeBuffer utils.Wr
if _autoSlaveDiscoveryErr != nil {
return errors.Wrap(_autoSlaveDiscoveryErr, "Error serializing 'autoSlaveDiscovery' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAutoSlaveDiscovery"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAutoSlaveDiscovery")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
index a4660e4f30..8ad3c125a3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataAverageValue interface {
IBACnetConstructedData
// GetAverageValue returns AverageValue (property field)
GetAverageValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataAverageValue) GetAverageValue() *BACnetApplication
return m.AverageValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAverageValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetAverageValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataAverageValue) GetLengthInBitsConditional(lastItem
// Simple field (averageValue)
lengthInBits += m.AverageValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataAverageValueParse(readBuffer utils.ReadBuffer, tagNumb
return nil, errors.Wrap(closeErr, "Error closing for averageValue")
}
+ // Virtual field
+ _actualValue := averageValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataAverageValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataAverageValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataAverageValue) Serialize(writeBuffer utils.WriteBuf
if _averageValueErr != nil {
return errors.Wrap(_averageValueErr, "Error serializing 'averageValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataAverageValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataAverageValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
index c6810f8c67..6f1ac7ab7b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPGlobalAddress.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPGlobalAddress interface {
IBACnetConstructedData
// GetBacnetIpGlobalAddress returns BacnetIpGlobalAddress (property field)
GetBacnetIpGlobalAddress() *BACnetHostNPort
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetHostNPort
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPGlobalAddress) GetBacnetIpGlobalAddress()
return m.BacnetIpGlobalAddress
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPGlobalAddress) GetActualValue() *BACnetHostNPort {
+ return CastBACnetHostNPort(m.GetBacnetIpGlobalAddress())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPGlobalAddress) GetLengthInBitsConditional(
// Simple field (bacnetIpGlobalAddress)
lengthInBits += m.BacnetIpGlobalAddress.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPGlobalAddressParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for bacnetIpGlobalAddress")
}
+ // Virtual field
+ _actualValue := bacnetIpGlobalAddress
+ actualValue := CastBACnetHostNPort(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPGlobalAddress"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPGlobalAddress")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPGlobalAddress) Serialize(writeBuffer utils
if _bacnetIpGlobalAddressErr != nil {
return errors.Wrap(_bacnetIpGlobalAddressErr, "Error serializing 'bacnetIpGlobalAddress' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPGlobalAddress"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPGlobalAddress")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
index c3627e3605..1865a7f445 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMode.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPMode interface {
IBACnetConstructedData
// GetBacnetIpMode returns BacnetIpMode (property field)
GetBacnetIpMode() *BACnetIPModeTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetIPModeTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPMode) GetBacnetIpMode() *BACnetIPModeTagge
return m.BacnetIpMode
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPMode) GetActualValue() *BACnetIPModeTagged {
+ return CastBACnetIPModeTagged(m.GetBacnetIpMode())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPMode) GetLengthInBitsConditional(lastItem
// Simple field (bacnetIpMode)
lengthInBits += m.BacnetIpMode.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPModeParse(readBuffer utils.ReadBuffer, tagNumb
return nil, errors.Wrap(closeErr, "Error closing for bacnetIpMode")
}
+ // Virtual field
+ _actualValue := bacnetIpMode
+ actualValue := CastBACnetIPModeTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPMode"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPMode")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPMode) Serialize(writeBuffer utils.WriteBuf
if _bacnetIpModeErr != nil {
return errors.Wrap(_bacnetIpModeErr, "Error serializing 'bacnetIpMode' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPMode"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPMode")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
index 23cddd57b1..180ca78d30 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPMulticastAddress.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPMulticastAddress interface {
IBACnetConstructedData
// GetIpMulticastAddress returns IpMulticastAddress (property field)
GetIpMulticastAddress() *BACnetApplicationTagOctetString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagOctetString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPMulticastAddress) GetIpMulticastAddress()
return m.IpMulticastAddress
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPMulticastAddress) GetActualValue() *BACnetApplicationTagOctetString {
+ return CastBACnetApplicationTagOctetString(m.GetIpMulticastAddress())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPMulticastAddress) GetLengthInBitsCondition
// Simple field (ipMulticastAddress)
lengthInBits += m.IpMulticastAddress.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPMulticastAddressParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for ipMulticastAddress")
}
+ // Virtual field
+ _actualValue := ipMulticastAddress
+ actualValue := CastBACnetApplicationTagOctetString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPMulticastAddress"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPMulticastAddress")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPMulticastAddress) Serialize(writeBuffer ut
if _ipMulticastAddressErr != nil {
return errors.Wrap(_ipMulticastAddressErr, "Error serializing 'ipMulticastAddress' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPMulticastAddress"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPMulticastAddress")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
index 611ce5c6dd..57e10eb114 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPNATTraversal.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPNATTraversal interface {
IBACnetConstructedData
// GetBacnetIPNATTraversal returns BacnetIPNATTraversal (property field)
GetBacnetIPNATTraversal() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPNATTraversal) GetBacnetIPNATTraversal() *B
return m.BacnetIPNATTraversal
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPNATTraversal) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetBacnetIPNATTraversal())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPNATTraversal) GetLengthInBitsConditional(l
// Simple field (bacnetIPNATTraversal)
lengthInBits += m.BacnetIPNATTraversal.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPNATTraversalParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for bacnetIPNATTraversal")
}
+ // Virtual field
+ _actualValue := bacnetIPNATTraversal
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPNATTraversal"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPNATTraversal")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPNATTraversal) Serialize(writeBuffer utils.
if _bacnetIPNATTraversalErr != nil {
return errors.Wrap(_bacnetIPNATTraversalErr, "Error serializing 'bacnetIPNATTraversal' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPNATTraversal"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPNATTraversal")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPUDPPort.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPUDPPort.go
index 7d93276f89..1241373be8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPUDPPort.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPUDPPort.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPUDPPort interface {
IBACnetConstructedData
// GetIpUdpPort returns IpUdpPort (property field)
GetIpUdpPort() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPUDPPort) GetIpUdpPort() *BACnetApplication
return m.IpUdpPort
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPUDPPort) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetIpUdpPort())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPUDPPort) GetLengthInBitsConditional(lastIt
// Simple field (ipUdpPort)
lengthInBits += m.IpUdpPort.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPUDPPortParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for ipUdpPort")
}
+ // Virtual field
+ _actualValue := ipUdpPort
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPUDPPort"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPUDPPort")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPUDPPort) Serialize(writeBuffer utils.Write
if _ipUdpPortErr != nil {
return errors.Wrap(_ipUdpPortErr, "Error serializing 'ipUdpPort' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPUDPPort"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPUDPPort")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6Mode.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6Mode.go
index 27a4ddff90..d7b3b10b67 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6Mode.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6Mode.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPv6Mode interface {
IBACnetConstructedData
// GetBacnetIpv6Mode returns BacnetIpv6Mode (property field)
GetBacnetIpv6Mode() *BACnetIPModeTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetIPModeTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPv6Mode) GetBacnetIpv6Mode() *BACnetIPModeT
return m.BacnetIpv6Mode
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPv6Mode) GetActualValue() *BACnetIPModeTagged {
+ return CastBACnetIPModeTagged(m.GetBacnetIpv6Mode())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPv6Mode) GetLengthInBitsConditional(lastIte
// Simple field (bacnetIpv6Mode)
lengthInBits += m.BacnetIpv6Mode.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPv6ModeParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for bacnetIpv6Mode")
}
+ // Virtual field
+ _actualValue := bacnetIpv6Mode
+ actualValue := CastBACnetIPModeTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPv6Mode"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPv6Mode")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPv6Mode) Serialize(writeBuffer utils.WriteB
if _bacnetIpv6ModeErr != nil {
return errors.Wrap(_bacnetIpv6ModeErr, "Error serializing 'bacnetIpv6Mode' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPv6Mode"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPv6Mode")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6MulticastAddress.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6MulticastAddress.go
index e671448373..2463af8382 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6MulticastAddress.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6MulticastAddress.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPv6MulticastAddress interface {
IBACnetConstructedData
// GetIpv6MulticastAddress returns Ipv6MulticastAddress (property field)
GetIpv6MulticastAddress() *BACnetApplicationTagOctetString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagOctetString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPv6MulticastAddress) GetIpv6MulticastAddres
return m.Ipv6MulticastAddress
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPv6MulticastAddress) GetActualValue() *BACnetApplicationTagOctetString {
+ return CastBACnetApplicationTagOctetString(m.GetIpv6MulticastAddress())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPv6MulticastAddress) GetLengthInBitsConditi
// Simple field (ipv6MulticastAddress)
lengthInBits += m.Ipv6MulticastAddress.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPv6MulticastAddressParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for ipv6MulticastAddress")
}
+ // Virtual field
+ _actualValue := ipv6MulticastAddress
+ actualValue := CastBACnetApplicationTagOctetString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPv6MulticastAddress"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPv6MulticastAddress")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPv6MulticastAddress) Serialize(writeBuffer
if _ipv6MulticastAddressErr != nil {
return errors.Wrap(_ipv6MulticastAddressErr, "Error serializing 'ipv6MulticastAddress' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPv6MulticastAddress"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPv6MulticastAddress")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6UDPPort.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6UDPPort.go
index e4d876e4c7..008d2e1659 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6UDPPort.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBACnetIPv6UDPPort.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBACnetIPv6UDPPort interface {
IBACnetConstructedData
// GetIpv6UdpPort returns Ipv6UdpPort (property field)
GetIpv6UdpPort() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBACnetIPv6UDPPort) GetIpv6UdpPort() *BACnetApplica
return m.Ipv6UdpPort
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBACnetIPv6UDPPort) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetIpv6UdpPort())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBACnetIPv6UDPPort) GetLengthInBitsConditional(last
// Simple field (ipv6UdpPort)
lengthInBits += m.Ipv6UdpPort.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBACnetIPv6UDPPortParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for ipv6UdpPort")
}
+ // Virtual field
+ _actualValue := ipv6UdpPort
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBACnetIPv6UDPPort"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBACnetIPv6UDPPort")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBACnetIPv6UDPPort) Serialize(writeBuffer utils.Wri
if _ipv6UdpPortErr != nil {
return errors.Wrap(_ipv6UdpPortErr, "Error serializing 'ipv6UdpPort' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBACnetIPv6UDPPort"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBACnetIPv6UDPPort")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go
index 59cf37e040..a856efabd7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBBMDAcceptFDRegistrations interface {
IBACnetConstructedData
// GetBbmdAcceptFDRegistrations returns BbmdAcceptFDRegistrations (property field)
GetBbmdAcceptFDRegistrations() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetBbmdAcceptFDRegistra
return m.BbmdAcceptFDRegistrations
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetBbmdAcceptFDRegistrations())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetLengthInBitsConditio
// Simple field (bbmdAcceptFDRegistrations)
lengthInBits += m.BbmdAcceptFDRegistrations.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBBMDAcceptFDRegistrationsParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for bbmdAcceptFDRegistrations")
}
+ // Virtual field
+ _actualValue := bbmdAcceptFDRegistrations
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBBMDAcceptFDRegistrations")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) Serialize(writeBuffer u
if _bbmdAcceptFDRegistrationsErr != nil {
return errors.Wrap(_bbmdAcceptFDRegistrationsErr, "Error serializing 'bbmdAcceptFDRegistrations' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBBMDAcceptFDRegistrations")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupAndRestoreState.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupAndRestoreState.go
index e794ee819b..2b03337769 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupAndRestoreState.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupAndRestoreState.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBackupAndRestoreState interface {
IBACnetConstructedData
// GetBackupAndRestoreState returns BackupAndRestoreState (property field)
GetBackupAndRestoreState() *BACnetBackupStateTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBackupStateTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBackupAndRestoreState) GetBackupAndRestoreState()
return m.BackupAndRestoreState
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBackupAndRestoreState) GetActualValue() *BACnetBackupStateTagged {
+ return CastBACnetBackupStateTagged(m.GetBackupAndRestoreState())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBackupAndRestoreState) GetLengthInBitsConditional(
// Simple field (backupAndRestoreState)
lengthInBits += m.BackupAndRestoreState.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBackupAndRestoreStateParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for backupAndRestoreState")
}
+ // Virtual field
+ _actualValue := backupAndRestoreState
+ actualValue := CastBACnetBackupStateTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBackupAndRestoreState"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBackupAndRestoreState")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBackupAndRestoreState) Serialize(writeBuffer utils
if _backupAndRestoreStateErr != nil {
return errors.Wrap(_backupAndRestoreStateErr, "Error serializing 'backupAndRestoreState' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBackupAndRestoreState"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBackupAndRestoreState")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupFailureTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupFailureTimeout.go
index fce3a916ad..9cb16ace3f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupFailureTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupFailureTimeout.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBackupFailureTimeout interface {
IBACnetConstructedData
// GetBackupFailureTimeout returns BackupFailureTimeout (property field)
GetBackupFailureTimeout() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBackupFailureTimeout) GetBackupFailureTimeout() *B
return m.BackupFailureTimeout
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBackupFailureTimeout) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetBackupFailureTimeout())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBackupFailureTimeout) GetLengthInBitsConditional(l
// Simple field (backupFailureTimeout)
lengthInBits += m.BackupFailureTimeout.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBackupFailureTimeoutParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for backupFailureTimeout")
}
+ // Virtual field
+ _actualValue := backupFailureTimeout
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBackupFailureTimeout"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBackupFailureTimeout")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBackupFailureTimeout) Serialize(writeBuffer utils.
if _backupFailureTimeoutErr != nil {
return errors.Wrap(_backupFailureTimeoutErr, "Error serializing 'backupFailureTimeout' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBackupFailureTimeout"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBackupFailureTimeout")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupPreparationTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupPreparationTime.go
index 1da2bc6372..0fecc84871 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupPreparationTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBackupPreparationTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBackupPreparationTime interface {
IBACnetConstructedData
// GetBackupPreparationTime returns BackupPreparationTime (property field)
GetBackupPreparationTime() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBackupPreparationTime) GetBackupPreparationTime()
return m.BackupPreparationTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBackupPreparationTime) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetBackupPreparationTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBackupPreparationTime) GetLengthInBitsConditional(
// Simple field (backupPreparationTime)
lengthInBits += m.BackupPreparationTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBackupPreparationTimeParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for backupPreparationTime")
}
+ // Virtual field
+ _actualValue := backupPreparationTime
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBackupPreparationTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBackupPreparationTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBackupPreparationTime) Serialize(writeBuffer utils
if _backupPreparationTimeErr != nil {
return errors.Wrap(_backupPreparationTimeErr, "Error serializing 'backupPreparationTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBackupPreparationTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBackupPreparationTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBaseDeviceSecurityPolicy.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBaseDeviceSecurityPolicy.go
index aad1a0a82e..1108f823f3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBaseDeviceSecurityPolicy.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBaseDeviceSecurityPolicy.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBaseDeviceSecurityPolicy interface {
IBACnetConstructedData
// GetBaseDeviceSecurityPolicy returns BaseDeviceSecurityPolicy (property field)
GetBaseDeviceSecurityPolicy() *BACnetSecurityLevelTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetSecurityLevelTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBaseDeviceSecurityPolicy) GetBaseDeviceSecurityPol
return m.BaseDeviceSecurityPolicy
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBaseDeviceSecurityPolicy) GetActualValue() *BACnetSecurityLevelTagged {
+ return CastBACnetSecurityLevelTagged(m.GetBaseDeviceSecurityPolicy())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBaseDeviceSecurityPolicy) GetLengthInBitsCondition
// Simple field (baseDeviceSecurityPolicy)
lengthInBits += m.BaseDeviceSecurityPolicy.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBaseDeviceSecurityPolicyParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for baseDeviceSecurityPolicy")
}
+ // Virtual field
+ _actualValue := baseDeviceSecurityPolicy
+ actualValue := CastBACnetSecurityLevelTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBaseDeviceSecurityPolicy"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBaseDeviceSecurityPolicy")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBaseDeviceSecurityPolicy) Serialize(writeBuffer ut
if _baseDeviceSecurityPolicyErr != nil {
return errors.Wrap(_baseDeviceSecurityPolicyErr, "Error serializing 'baseDeviceSecurityPolicy' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBaseDeviceSecurityPolicy"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBaseDeviceSecurityPolicy")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBelongsTo.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBelongsTo.go
index 336bfa9f3a..878e3038da 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBelongsTo.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBelongsTo.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBelongsTo interface {
IBACnetConstructedData
// GetBelongsTo returns BelongsTo (property field)
GetBelongsTo() *BACnetDeviceObjectReference
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDeviceObjectReference
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBelongsTo) GetBelongsTo() *BACnetDeviceObjectRefer
return m.BelongsTo
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBelongsTo) GetActualValue() *BACnetDeviceObjectReference {
+ return CastBACnetDeviceObjectReference(m.GetBelongsTo())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBelongsTo) GetLengthInBitsConditional(lastItem boo
// Simple field (belongsTo)
lengthInBits += m.BelongsTo.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBelongsToParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for belongsTo")
}
+ // Virtual field
+ _actualValue := belongsTo
+ actualValue := CastBACnetDeviceObjectReference(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBelongsTo"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBelongsTo")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBelongsTo) Serialize(writeBuffer utils.WriteBuffer
if _belongsToErr != nil {
return errors.Wrap(_belongsToErr, "Error serializing 'belongsTo' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBelongsTo"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBelongsTo")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBias.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBias.go
index 08618f2eff..36782243bb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBias.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBias.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBias interface {
IBACnetConstructedData
// GetBias returns Bias (property field)
GetBias() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBias) GetBias() *BACnetApplicationTagReal {
return m.Bias
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBias) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetBias())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBias) GetLengthInBitsConditional(lastItem bool) ui
// Simple field (bias)
lengthInBits += m.Bias.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBiasParse(readBuffer utils.ReadBuffer, tagNumber uint8
return nil, errors.Wrap(closeErr, "Error closing for bias")
}
+ // Virtual field
+ _actualValue := bias
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBias"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBias")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBias) Serialize(writeBuffer utils.WriteBuffer) err
if _biasErr != nil {
return errors.Wrap(_biasErr, "Error serializing 'bias' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBias"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBias")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputInterfaceValue.go
index b6cb783668..a602d563bf 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputInterfaceValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryInputInterfaceValue interface {
IBACnetConstructedData
// GetInterfaceValue returns InterfaceValue (property field)
GetInterfaceValue() *BACnetOptionalBinaryPV
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetOptionalBinaryPV
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryInputInterfaceValue) GetInterfaceValue() *BA
return m.InterfaceValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryInputInterfaceValue) GetActualValue() *BACnetOptionalBinaryPV {
+ return CastBACnetOptionalBinaryPV(m.GetInterfaceValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryInputInterfaceValue) GetLengthInBitsConditio
// Simple field (interfaceValue)
lengthInBits += m.InterfaceValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryInputInterfaceValueParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for interfaceValue")
}
+ // Virtual field
+ _actualValue := interfaceValue
+ actualValue := CastBACnetOptionalBinaryPV(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryInputInterfaceValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryInputInterfaceValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryInputInterfaceValue) Serialize(writeBuffer u
if _interfaceValueErr != nil {
return errors.Wrap(_interfaceValueErr, "Error serializing 'interfaceValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryInputInterfaceValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryInputInterfaceValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputPresentValue.go
index 0c629a7af5..cd6db08f02 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryInputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryInputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryInputPresentValue) GetPresentValue() *BACnet
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryInputPresentValue) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryInputPresentValue) GetLengthInBitsConditiona
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryInputPresentValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryInputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryInputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryInputPresentValue) Serialize(writeBuffer uti
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryInputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryInputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputFeedbackValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputFeedbackValue.go
index 3dadf89846..6f120e0a82 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputFeedbackValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputFeedbackValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryLightingOutputFeedbackValue interface {
IBACnetConstructedData
// GetFeedbackValue returns FeedbackValue (property field)
GetFeedbackValue() *BACnetBinaryLightingPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryLightingPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryLightingOutputFeedbackValue) GetFeedbackValu
return m.FeedbackValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryLightingOutputFeedbackValue) GetActualValue() *BACnetBinaryLightingPVTagged {
+ return CastBACnetBinaryLightingPVTagged(m.GetFeedbackValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryLightingOutputFeedbackValue) GetLengthInBits
// Simple field (feedbackValue)
lengthInBits += m.FeedbackValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryLightingOutputFeedbackValueParse(readBuffer util
return nil, errors.Wrap(closeErr, "Error closing for feedbackValue")
}
+ // Virtual field
+ _actualValue := feedbackValue
+ actualValue := CastBACnetBinaryLightingPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryLightingOutputFeedbackValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryLightingOutputFeedbackValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryLightingOutputFeedbackValue) Serialize(write
if _feedbackValueErr != nil {
return errors.Wrap(_feedbackValueErr, "Error serializing 'feedbackValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryLightingOutputFeedbackValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryLightingOutputFeedbackValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputPresentValue.go
index cf684e3af7..923ecea8c8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryLightingOutputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetBinaryLightingPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryLightingPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryLightingOutputPresentValue) GetPresentValue(
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryLightingOutputPresentValue) GetActualValue() *BACnetBinaryLightingPVTagged {
+ return CastBACnetBinaryLightingPVTagged(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryLightingOutputPresentValue) GetLengthInBitsC
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryLightingOutputPresentValueParse(readBuffer utils
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetBinaryLightingPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryLightingOutputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryLightingOutputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryLightingOutputPresentValue) Serialize(writeB
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryLightingOutputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryLightingOutputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputRelinquishDefault.go
index e60019ac9e..1f5c6326df 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryLightingOutputRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryLightingOutputRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetBinaryLightingPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryLightingPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryLightingOutputRelinquishDefault) GetRelinqui
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryLightingOutputRelinquishDefault) GetActualValue() *BACnetBinaryLightingPVTagged {
+ return CastBACnetBinaryLightingPVTagged(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryLightingOutputRelinquishDefault) GetLengthIn
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryLightingOutputRelinquishDefaultParse(readBuffer
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetBinaryLightingPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryLightingOutputRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryLightingOutputRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryLightingOutputRelinquishDefault) Serialize(w
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryLightingOutputRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryLightingOutputRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputFeedbackValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputFeedbackValue.go
index b110c21f28..e22a8ab85f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputFeedbackValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputFeedbackValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryOutputFeedbackValue interface {
IBACnetConstructedData
// GetFeedbackValue returns FeedbackValue (property field)
GetFeedbackValue() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryOutputFeedbackValue) GetFeedbackValue() *BAC
return m.FeedbackValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryOutputFeedbackValue) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetFeedbackValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryOutputFeedbackValue) GetLengthInBitsConditio
// Simple field (feedbackValue)
lengthInBits += m.FeedbackValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryOutputFeedbackValueParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for feedbackValue")
}
+ // Virtual field
+ _actualValue := feedbackValue
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryOutputFeedbackValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryOutputFeedbackValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryOutputFeedbackValue) Serialize(writeBuffer u
if _feedbackValueErr != nil {
return errors.Wrap(_feedbackValueErr, "Error serializing 'feedbackValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryOutputFeedbackValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryOutputFeedbackValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputInterfaceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputInterfaceValue.go
index 6a641687c9..3d6ce778f6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputInterfaceValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputInterfaceValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryOutputInterfaceValue interface {
IBACnetConstructedData
// GetInterfaceValue returns InterfaceValue (property field)
GetInterfaceValue() *BACnetOptionalBinaryPV
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetOptionalBinaryPV
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryOutputInterfaceValue) GetInterfaceValue() *B
return m.InterfaceValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryOutputInterfaceValue) GetActualValue() *BACnetOptionalBinaryPV {
+ return CastBACnetOptionalBinaryPV(m.GetInterfaceValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryOutputInterfaceValue) GetLengthInBitsConditi
// Simple field (interfaceValue)
lengthInBits += m.InterfaceValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryOutputInterfaceValueParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for interfaceValue")
}
+ // Virtual field
+ _actualValue := interfaceValue
+ actualValue := CastBACnetOptionalBinaryPV(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryOutputInterfaceValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryOutputInterfaceValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryOutputInterfaceValue) Serialize(writeBuffer
if _interfaceValueErr != nil {
return errors.Wrap(_interfaceValueErr, "Error serializing 'interfaceValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryOutputInterfaceValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryOutputInterfaceValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputPresentValue.go
index fb79203ab8..92a49021ee 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryOutputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryOutputPresentValue) GetPresentValue() *BACne
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryOutputPresentValue) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryOutputPresentValue) GetLengthInBitsCondition
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryOutputPresentValueParse(readBuffer utils.ReadBuf
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryOutputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryOutputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryOutputPresentValue) Serialize(writeBuffer ut
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryOutputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryOutputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputRelinquishDefault.go
index 9263a6cc74..a8aac2ca36 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryOutputRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryOutputRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryOutputRelinquishDefault) GetRelinquishDefaul
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryOutputRelinquishDefault) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryOutputRelinquishDefault) GetLengthInBitsCond
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryOutputRelinquishDefaultParse(readBuffer utils.Re
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryOutputRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryOutputRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryOutputRelinquishDefault) Serialize(writeBuff
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryOutputRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryOutputRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValuePresentValue.go
index ed083aea92..16902b5fd6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryValuePresentValue) GetPresentValue() *BACnet
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryValuePresentValue) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryValuePresentValue) GetLengthInBitsConditiona
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryValuePresentValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryValuePresentValue) Serialize(writeBuffer uti
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValueRelinquishDefault.go
index 54765bb465..92496a4a8e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBinaryValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBinaryValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBinaryValueRelinquishDefault) GetRelinquishDefault
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBinaryValueRelinquishDefault) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBinaryValueRelinquishDefault) GetLengthInBitsCondi
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBinaryValueRelinquishDefaultParse(readBuffer utils.Rea
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBinaryValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBinaryValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBinaryValueRelinquishDefault) Serialize(writeBuffe
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBinaryValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBinaryValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitMask.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitMask.go
index f5ac4a6674..249bf75c1e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitMask.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitMask.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBitMask interface {
IBACnetConstructedData
// GetBitString returns BitString (property field)
GetBitString() *BACnetApplicationTagBitString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBitString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBitMask) GetBitString() *BACnetApplicationTagBitSt
return m.BitString
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBitMask) GetActualValue() *BACnetApplicationTagBitString {
+ return CastBACnetApplicationTagBitString(m.GetBitString())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBitMask) GetLengthInBitsConditional(lastItem bool)
// Simple field (bitString)
lengthInBits += m.BitString.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBitMaskParse(readBuffer utils.ReadBuffer, tagNumber ui
return nil, errors.Wrap(closeErr, "Error closing for bitString")
}
+ // Virtual field
+ _actualValue := bitString
+ actualValue := CastBACnetApplicationTagBitString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBitMask"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBitMask")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBitMask) Serialize(writeBuffer utils.WriteBuffer)
if _bitStringErr != nil {
return errors.Wrap(_bitStringErr, "Error serializing 'bitString' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBitMask"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBitMask")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValuePresentValue.go
index 814d7cc20b..1004fdbb83 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBitStringValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagBitString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBitString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBitStringValuePresentValue) GetPresentValue() *BAC
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBitStringValuePresentValue) GetActualValue() *BACnetApplicationTagBitString {
+ return CastBACnetApplicationTagBitString(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBitStringValuePresentValue) GetLengthInBitsConditi
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBitStringValuePresentValueParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagBitString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBitStringValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBitStringValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBitStringValuePresentValue) Serialize(writeBuffer
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBitStringValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBitStringValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValueRelinquishDefault.go
index ba046f36b9..110561d5a0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBitStringValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBitStringValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagBitString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBitString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBitStringValueRelinquishDefault) GetRelinquishDefa
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBitStringValueRelinquishDefault) GetActualValue() *BACnetApplicationTagBitString {
+ return CastBACnetApplicationTagBitString(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBitStringValueRelinquishDefault) GetLengthInBitsCo
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBitStringValueRelinquishDefaultParse(readBuffer utils.
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagBitString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBitStringValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBitStringValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBitStringValueRelinquishDefault) Serialize(writeBu
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBitStringValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBitStringValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBlinkWarnEnable.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBlinkWarnEnable.go
index 02559f7be8..f3854e47af 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBlinkWarnEnable.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBlinkWarnEnable.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBlinkWarnEnable interface {
IBACnetConstructedData
// GetBlinkWarnEnable returns BlinkWarnEnable (property field)
GetBlinkWarnEnable() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBlinkWarnEnable) GetBlinkWarnEnable() *BACnetAppli
return m.BlinkWarnEnable
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBlinkWarnEnable) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetBlinkWarnEnable())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBlinkWarnEnable) GetLengthInBitsConditional(lastIt
// Simple field (blinkWarnEnable)
lengthInBits += m.BlinkWarnEnable.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBlinkWarnEnableParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for blinkWarnEnable")
}
+ // Virtual field
+ _actualValue := blinkWarnEnable
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBlinkWarnEnable"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBlinkWarnEnable")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBlinkWarnEnable) Serialize(writeBuffer utils.Write
if _blinkWarnEnableErr != nil {
return errors.Wrap(_blinkWarnEnableErr, "Error serializing 'blinkWarnEnable' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBlinkWarnEnable"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBlinkWarnEnable")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBufferSize.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBufferSize.go
index 652498f668..f11c1417ac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBufferSize.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBufferSize.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataBufferSize interface {
IBACnetConstructedData
// GetBufferSize returns BufferSize (property field)
GetBufferSize() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataBufferSize) GetBufferSize() *BACnetApplicationTagU
return m.BufferSize
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBufferSize) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetBufferSize())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataBufferSize) GetLengthInBitsConditional(lastItem bo
// Simple field (bufferSize)
lengthInBits += m.BufferSize.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataBufferSizeParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for bufferSize")
}
+ // Virtual field
+ _actualValue := bufferSize
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataBufferSize"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataBufferSize")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataBufferSize) Serialize(writeBuffer utils.WriteBuffe
if _bufferSizeErr != nil {
return errors.Wrap(_bufferSizeErr, "Error serializing 'bufferSize' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataBufferSize"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataBufferSize")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVIncrement.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVIncrement.go
index 4a332bf2b1..bbec57b630 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVIncrement.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVIncrement.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCOVIncrement interface {
IBACnetConstructedData
// GetCovIncrement returns CovIncrement (property field)
GetCovIncrement() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCOVIncrement) GetCovIncrement() *BACnetApplication
return m.CovIncrement
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCOVIncrement) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetCovIncrement())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCOVIncrement) GetLengthInBitsConditional(lastItem
// Simple field (covIncrement)
lengthInBits += m.CovIncrement.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCOVIncrementParse(readBuffer utils.ReadBuffer, tagNumb
return nil, errors.Wrap(closeErr, "Error closing for covIncrement")
}
+ // Virtual field
+ _actualValue := covIncrement
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCOVIncrement"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCOVIncrement")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCOVIncrement) Serialize(writeBuffer utils.WriteBuf
if _covIncrementErr != nil {
return errors.Wrap(_covIncrementErr, "Error serializing 'covIncrement' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCOVIncrement"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCOVIncrement")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVPeriod.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVPeriod.go
index 9977cafba2..90dfcf40df 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVPeriod.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVPeriod.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCOVPeriod interface {
IBACnetConstructedData
// GetCovPeriod returns CovPeriod (property field)
GetCovPeriod() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCOVPeriod) GetCovPeriod() *BACnetApplicationTagUns
return m.CovPeriod
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCOVPeriod) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCovPeriod())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCOVPeriod) GetLengthInBitsConditional(lastItem boo
// Simple field (covPeriod)
lengthInBits += m.CovPeriod.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCOVPeriodParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for covPeriod")
}
+ // Virtual field
+ _actualValue := covPeriod
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCOVPeriod"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCOVPeriod")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCOVPeriod) Serialize(writeBuffer utils.WriteBuffer
if _covPeriodErr != nil {
return errors.Wrap(_covPeriodErr, "Error serializing 'covPeriod' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCOVPeriod"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCOVPeriod")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVResubscriptionInterval.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVResubscriptionInterval.go
index 85e31754f8..8127a8469f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVResubscriptionInterval.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVResubscriptionInterval.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCOVResubscriptionInterval interface {
IBACnetConstructedData
// GetCovResubscriptionInterval returns CovResubscriptionInterval (property field)
GetCovResubscriptionInterval() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCOVResubscriptionInterval) GetCovResubscriptionInt
return m.CovResubscriptionInterval
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCOVResubscriptionInterval) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCovResubscriptionInterval())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCOVResubscriptionInterval) GetLengthInBitsConditio
// Simple field (covResubscriptionInterval)
lengthInBits += m.CovResubscriptionInterval.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCOVResubscriptionIntervalParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for covResubscriptionInterval")
}
+ // Virtual field
+ _actualValue := covResubscriptionInterval
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCOVResubscriptionInterval"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCOVResubscriptionInterval")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCOVResubscriptionInterval) Serialize(writeBuffer u
if _covResubscriptionIntervalErr != nil {
return errors.Wrap(_covResubscriptionIntervalErr, "Error serializing 'covResubscriptionInterval' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCOVResubscriptionInterval"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCOVResubscriptionInterval")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVUPeriod.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVUPeriod.go
index 495c7df89a..df807b56fd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVUPeriod.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCOVUPeriod.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCOVUPeriod interface {
IBACnetConstructedData
// GetCovuPeriod returns CovuPeriod (property field)
GetCovuPeriod() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCOVUPeriod) GetCovuPeriod() *BACnetApplicationTagU
return m.CovuPeriod
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCOVUPeriod) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCovuPeriod())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCOVUPeriod) GetLengthInBitsConditional(lastItem bo
// Simple field (covuPeriod)
lengthInBits += m.CovuPeriod.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCOVUPeriodParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for covuPeriod")
}
+ // Virtual field
+ _actualValue := covuPeriod
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCOVUPeriod"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCOVUPeriod")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCOVUPeriod) Serialize(writeBuffer utils.WriteBuffe
if _covuPeriodErr != nil {
return errors.Wrap(_covuPeriodErr, "Error serializing 'covuPeriod' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCOVUPeriod"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCOVUPeriod")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCalendarPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCalendarPresentValue.go
index 17ce6bfbc0..8dffa4917c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCalendarPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCalendarPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCalendarPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCalendarPresentValue) GetPresentValue() *BACnetApp
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCalendarPresentValue) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCalendarPresentValue) GetLengthInBitsConditional(l
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCalendarPresentValueParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCalendarPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCalendarPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCalendarPresentValue) Serialize(writeBuffer utils.
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCalendarPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCalendarPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarAssignedDirection.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarAssignedDirection.go
index 595be85fb1..ca3ec654dd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarAssignedDirection.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarAssignedDirection.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarAssignedDirection interface {
IBACnetConstructedData
// GetAssignedDirection returns AssignedDirection (property field)
GetAssignedDirection() *BACnetLiftCarDirectionTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetLiftCarDirectionTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarAssignedDirection) GetAssignedDirection() *BACn
return m.AssignedDirection
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarAssignedDirection) GetActualValue() *BACnetLiftCarDirectionTagged {
+ return CastBACnetLiftCarDirectionTagged(m.GetAssignedDirection())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarAssignedDirection) GetLengthInBitsConditional(l
// Simple field (assignedDirection)
lengthInBits += m.AssignedDirection.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarAssignedDirectionParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for assignedDirection")
}
+ // Virtual field
+ _actualValue := assignedDirection
+ actualValue := CastBACnetLiftCarDirectionTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarAssignedDirection"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarAssignedDirection")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarAssignedDirection) Serialize(writeBuffer utils.
if _assignedDirectionErr != nil {
return errors.Wrap(_assignedDirectionErr, "Error serializing 'assignedDirection' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarAssignedDirection"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarAssignedDirection")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDoorZone.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDoorZone.go
index e12102cdc0..4e147dca39 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDoorZone.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDoorZone.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarDoorZone interface {
IBACnetConstructedData
// GetCarDoorZone returns CarDoorZone (property field)
GetCarDoorZone() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarDoorZone) GetCarDoorZone() *BACnetApplicationTa
return m.CarDoorZone
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarDoorZone) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetCarDoorZone())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarDoorZone) GetLengthInBitsConditional(lastItem b
// Simple field (carDoorZone)
lengthInBits += m.CarDoorZone.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarDoorZoneParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for carDoorZone")
}
+ // Virtual field
+ _actualValue := carDoorZone
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarDoorZone"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarDoorZone")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarDoorZone) Serialize(writeBuffer utils.WriteBuff
if _carDoorZoneErr != nil {
return errors.Wrap(_carDoorZoneErr, "Error serializing 'carDoorZone' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarDoorZone"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarDoorZone")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDriveStatus.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDriveStatus.go
index 4f097c8a8d..17e0d967cd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDriveStatus.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarDriveStatus.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarDriveStatus interface {
IBACnetConstructedData
// GetCarDriveStatus returns CarDriveStatus (property field)
GetCarDriveStatus() *BACnetLiftCarDriveStatusTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetLiftCarDriveStatusTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarDriveStatus) GetCarDriveStatus() *BACnetLiftCar
return m.CarDriveStatus
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarDriveStatus) GetActualValue() *BACnetLiftCarDriveStatusTagged {
+ return CastBACnetLiftCarDriveStatusTagged(m.GetCarDriveStatus())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarDriveStatus) GetLengthInBitsConditional(lastIte
// Simple field (carDriveStatus)
lengthInBits += m.CarDriveStatus.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarDriveStatusParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for carDriveStatus")
}
+ // Virtual field
+ _actualValue := carDriveStatus
+ actualValue := CastBACnetLiftCarDriveStatusTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarDriveStatus"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarDriveStatus")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarDriveStatus) Serialize(writeBuffer utils.WriteB
if _carDriveStatusErr != nil {
return errors.Wrap(_carDriveStatusErr, "Error serializing 'carDriveStatus' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarDriveStatus"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarDriveStatus")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoad.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoad.go
index e882fedc1a..b1dba450e4 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoad.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoad.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarLoad interface {
IBACnetConstructedData
// GetCarLoad returns CarLoad (property field)
GetCarLoad() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarLoad) GetCarLoad() *BACnetApplicationTagReal {
return m.CarLoad
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarLoad) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetCarLoad())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarLoad) GetLengthInBitsConditional(lastItem bool)
// Simple field (carLoad)
lengthInBits += m.CarLoad.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarLoadParse(readBuffer utils.ReadBuffer, tagNumber ui
return nil, errors.Wrap(closeErr, "Error closing for carLoad")
}
+ // Virtual field
+ _actualValue := carLoad
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarLoad"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarLoad")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarLoad) Serialize(writeBuffer utils.WriteBuffer)
if _carLoadErr != nil {
return errors.Wrap(_carLoadErr, "Error serializing 'carLoad' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarLoad"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarLoad")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoadUnits.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoadUnits.go
index 97b4580144..7ef03cc7e9 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoadUnits.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarLoadUnits.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarLoadUnits interface {
IBACnetConstructedData
// GetUnits returns Units (property field)
GetUnits() *BACnetEngineeringUnitsTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetEngineeringUnitsTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarLoadUnits) GetUnits() *BACnetEngineeringUnitsTa
return m.Units
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarLoadUnits) GetActualValue() *BACnetEngineeringUnitsTagged {
+ return CastBACnetEngineeringUnitsTagged(m.GetUnits())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarLoadUnits) GetLengthInBitsConditional(lastItem
// Simple field (units)
lengthInBits += m.Units.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarLoadUnitsParse(readBuffer utils.ReadBuffer, tagNumb
return nil, errors.Wrap(closeErr, "Error closing for units")
}
+ // Virtual field
+ _actualValue := units
+ actualValue := CastBACnetEngineeringUnitsTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarLoadUnits"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarLoadUnits")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarLoadUnits) Serialize(writeBuffer utils.WriteBuf
if _unitsErr != nil {
return errors.Wrap(_unitsErr, "Error serializing 'units' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarLoadUnits"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarLoadUnits")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMode.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMode.go
index 1fccd24023..e1928dba07 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMode.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMode.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarMode interface {
IBACnetConstructedData
// GetCarMode returns CarMode (property field)
GetCarMode() *BACnetLiftCarModeTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetLiftCarModeTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarMode) GetCarMode() *BACnetLiftCarModeTagged {
return m.CarMode
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarMode) GetActualValue() *BACnetLiftCarModeTagged {
+ return CastBACnetLiftCarModeTagged(m.GetCarMode())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarMode) GetLengthInBitsConditional(lastItem bool)
// Simple field (carMode)
lengthInBits += m.CarMode.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarModeParse(readBuffer utils.ReadBuffer, tagNumber ui
return nil, errors.Wrap(closeErr, "Error closing for carMode")
}
+ // Virtual field
+ _actualValue := carMode
+ actualValue := CastBACnetLiftCarModeTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarMode"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarMode")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarMode) Serialize(writeBuffer utils.WriteBuffer)
if _carModeErr != nil {
return errors.Wrap(_carModeErr, "Error serializing 'carMode' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarMode"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarMode")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMovingDirection.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMovingDirection.go
index 75621e8920..89129faef0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMovingDirection.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarMovingDirection.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarMovingDirection interface {
IBACnetConstructedData
// GetCarMovingDirection returns CarMovingDirection (property field)
GetCarMovingDirection() *BACnetLiftCarDirectionTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetLiftCarDirectionTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarMovingDirection) GetCarMovingDirection() *BACne
return m.CarMovingDirection
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarMovingDirection) GetActualValue() *BACnetLiftCarDirectionTagged {
+ return CastBACnetLiftCarDirectionTagged(m.GetCarMovingDirection())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarMovingDirection) GetLengthInBitsConditional(las
// Simple field (carMovingDirection)
lengthInBits += m.CarMovingDirection.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarMovingDirectionParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for carMovingDirection")
}
+ // Virtual field
+ _actualValue := carMovingDirection
+ actualValue := CastBACnetLiftCarDirectionTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarMovingDirection"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarMovingDirection")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarMovingDirection) Serialize(writeBuffer utils.Wr
if _carMovingDirectionErr != nil {
return errors.Wrap(_carMovingDirectionErr, "Error serializing 'carMovingDirection' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarMovingDirection"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarMovingDirection")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarPosition.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarPosition.go
index 5f502b1db5..0b42f89e13 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarPosition.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCarPosition.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCarPosition interface {
IBACnetConstructedData
// GetCarPosition returns CarPosition (property field)
GetCarPosition() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCarPosition) GetCarPosition() *BACnetApplicationTa
return m.CarPosition
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCarPosition) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCarPosition())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCarPosition) GetLengthInBitsConditional(lastItem b
// Simple field (carPosition)
lengthInBits += m.CarPosition.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCarPositionParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for carPosition")
}
+ // Virtual field
+ _actualValue := carPosition
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCarPosition"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCarPosition")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCarPosition) Serialize(writeBuffer utils.WriteBuff
if _carPositionErr != nil {
return errors.Wrap(_carPositionErr, "Error serializing 'carPosition' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCarPosition"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCarPosition")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateCount.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateCount.go
index 4f751eb8a6..ecd2b6eaf1 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateCount.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateCount.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataChangeOfStateCount interface {
IBACnetConstructedData
// GetChangeIfStateCount returns ChangeIfStateCount (property field)
GetChangeIfStateCount() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataChangeOfStateCount) GetChangeIfStateCount() *BACne
return m.ChangeIfStateCount
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataChangeOfStateCount) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetChangeIfStateCount())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataChangeOfStateCount) GetLengthInBitsConditional(las
// Simple field (changeIfStateCount)
lengthInBits += m.ChangeIfStateCount.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataChangeOfStateCountParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for changeIfStateCount")
}
+ // Virtual field
+ _actualValue := changeIfStateCount
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataChangeOfStateCount"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataChangeOfStateCount")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataChangeOfStateCount) Serialize(writeBuffer utils.Wr
if _changeIfStateCountErr != nil {
return errors.Wrap(_changeIfStateCountErr, "Error serializing 'changeIfStateCount' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataChangeOfStateCount"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataChangeOfStateCount")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateTime.go
index 46f41edb56..54733d0284 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangeOfStateTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataChangeOfStateTime interface {
IBACnetConstructedData
// GetChangeOfStateTime returns ChangeOfStateTime (property field)
GetChangeOfStateTime() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataChangeOfStateTime) GetChangeOfStateTime() *BACnetD
return m.ChangeOfStateTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataChangeOfStateTime) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetChangeOfStateTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataChangeOfStateTime) GetLengthInBitsConditional(last
// Simple field (changeOfStateTime)
lengthInBits += m.ChangeOfStateTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataChangeOfStateTimeParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for changeOfStateTime")
}
+ // Virtual field
+ _actualValue := changeOfStateTime
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataChangeOfStateTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataChangeOfStateTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataChangeOfStateTime) Serialize(writeBuffer utils.Wri
if _changeOfStateTimeErr != nil {
return errors.Wrap(_changeOfStateTimeErr, "Error serializing 'changeOfStateTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataChangeOfStateTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataChangeOfStateTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangesPending.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangesPending.go
index 0752b31785..bc1ebf7507 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangesPending.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChangesPending.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataChangesPending interface {
IBACnetConstructedData
// GetChangesPending returns ChangesPending (property field)
GetChangesPending() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataChangesPending) GetChangesPending() *BACnetApplica
return m.ChangesPending
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataChangesPending) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetChangesPending())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataChangesPending) GetLengthInBitsConditional(lastIte
// Simple field (changesPending)
lengthInBits += m.ChangesPending.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataChangesPendingParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for changesPending")
}
+ // Virtual field
+ _actualValue := changesPending
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataChangesPending"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataChangesPending")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataChangesPending) Serialize(writeBuffer utils.WriteB
if _changesPendingErr != nil {
return errors.Wrap(_changesPendingErr, "Error serializing 'changesPending' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataChangesPending"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataChangesPending")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelNumber.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelNumber.go
index a137e5c3bd..3aae6da8d6 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelNumber.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelNumber.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataChannelNumber interface {
IBACnetConstructedData
// GetChannelNumber returns ChannelNumber (property field)
GetChannelNumber() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataChannelNumber) GetChannelNumber() *BACnetApplicati
return m.ChannelNumber
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataChannelNumber) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetChannelNumber())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataChannelNumber) GetLengthInBitsConditional(lastItem
// Simple field (channelNumber)
lengthInBits += m.ChannelNumber.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataChannelNumberParse(readBuffer utils.ReadBuffer, tagNum
return nil, errors.Wrap(closeErr, "Error closing for channelNumber")
}
+ // Virtual field
+ _actualValue := channelNumber
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataChannelNumber"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataChannelNumber")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataChannelNumber) Serialize(writeBuffer utils.WriteBu
if _channelNumberErr != nil {
return errors.Wrap(_channelNumberErr, "Error serializing 'channelNumber' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataChannelNumber"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataChannelNumber")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelPresentValue.go
index ffaf819a1a..c33dac62b7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataChannelPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataChannelPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetChannelValue
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetChannelValue
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataChannelPresentValue) GetPresentValue() *BACnetChan
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataChannelPresentValue) GetActualValue() *BACnetChannelValue {
+ return CastBACnetChannelValue(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataChannelPresentValue) GetLengthInBitsConditional(la
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataChannelPresentValueParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetChannelValue(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataChannelPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataChannelPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataChannelPresentValue) Serialize(writeBuffer utils.W
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataChannelPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataChannelPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValuePresentValue.go
index 175931581b..f78cdd7c2c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCharacterStringValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCharacterStringValuePresentValue) GetPresentValue(
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCharacterStringValuePresentValue) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCharacterStringValuePresentValue) GetLengthInBitsC
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCharacterStringValuePresentValueParse(readBuffer utils
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCharacterStringValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCharacterStringValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCharacterStringValuePresentValue) Serialize(writeB
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCharacterStringValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCharacterStringValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValueRelinquishDefault.go
index 836eb79c4b..19ac8206cd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCharacterStringValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCharacterStringValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCharacterStringValueRelinquishDefault) GetRelinqui
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCharacterStringValueRelinquishDefault) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCharacterStringValueRelinquishDefault) GetLengthIn
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCharacterStringValueRelinquishDefaultParse(readBuffer
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCharacterStringValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCharacterStringValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCharacterStringValueRelinquishDefault) Serialize(w
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCharacterStringValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCharacterStringValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataClientCOVIncrement.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataClientCOVIncrement.go
index 34d258c26c..acf9f97a50 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataClientCOVIncrement.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataClientCOVIncrement.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataClientCOVIncrement interface {
IBACnetConstructedData
// GetCovIncrement returns CovIncrement (property field)
GetCovIncrement() *BACnetClientCOV
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetClientCOV
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataClientCOVIncrement) GetCovIncrement() *BACnetClien
return m.CovIncrement
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataClientCOVIncrement) GetActualValue() *BACnetClientCOV {
+ return CastBACnetClientCOV(m.GetCovIncrement())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataClientCOVIncrement) GetLengthInBitsConditional(las
// Simple field (covIncrement)
lengthInBits += m.CovIncrement.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataClientCOVIncrementParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for covIncrement")
}
+ // Virtual field
+ _actualValue := covIncrement
+ actualValue := CastBACnetClientCOV(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataClientCOVIncrement"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataClientCOVIncrement")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataClientCOVIncrement) Serialize(writeBuffer utils.Wr
if _covIncrementErr != nil {
return errors.Wrap(_covIncrementErr, "Error serializing 'covIncrement' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataClientCOVIncrement"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataClientCOVIncrement")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCommand.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
index 0a42bc15f3..3c8eee7fa7 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCommand interface {
IBACnetConstructedData
// GetCommand returns Command (property field)
GetCommand() *BACnetNetworkPortCommandTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetNetworkPortCommandTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCommand) GetCommand() *BACnetNetworkPortCommandTag
return m.Command
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCommand) GetActualValue() *BACnetNetworkPortCommandTagged {
+ return CastBACnetNetworkPortCommandTagged(m.GetCommand())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCommand) GetLengthInBitsConditional(lastItem bool)
// Simple field (command)
lengthInBits += m.Command.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCommandParse(readBuffer utils.ReadBuffer, tagNumber ui
return nil, errors.Wrap(closeErr, "Error closing for command")
}
+ // Virtual field
+ _actualValue := command
+ actualValue := CastBACnetNetworkPortCommandTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCommand"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCommand")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCommand) Serialize(writeBuffer utils.WriteBuffer)
if _commandErr != nil {
return errors.Wrap(_commandErr, "Error serializing 'command' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCommand"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCommand")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableReference.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableReference.go
index 414b977731..3ad3297fac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableReference.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableReference.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataControlledVariableReference interface {
IBACnetConstructedData
// GetControlledVariableReference returns ControlledVariableReference (property field)
GetControlledVariableReference() *BACnetObjectPropertyReference
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetObjectPropertyReference
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataControlledVariableReference) GetControlledVariable
return m.ControlledVariableReference
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataControlledVariableReference) GetActualValue() *BACnetObjectPropertyReference {
+ return CastBACnetObjectPropertyReference(m.GetControlledVariableReference())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataControlledVariableReference) GetLengthInBitsCondit
// Simple field (controlledVariableReference)
lengthInBits += m.ControlledVariableReference.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataControlledVariableReferenceParse(readBuffer utils.Read
return nil, errors.Wrap(closeErr, "Error closing for controlledVariableReference")
}
+ // Virtual field
+ _actualValue := controlledVariableReference
+ actualValue := CastBACnetObjectPropertyReference(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataControlledVariableReference"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataControlledVariableReference")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataControlledVariableReference) Serialize(writeBuffer
if _controlledVariableReferenceErr != nil {
return errors.Wrap(_controlledVariableReferenceErr, "Error serializing 'controlledVariableReference' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataControlledVariableReference"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataControlledVariableReference")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableUnits.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableUnits.go
index 2ce3169e5c..3e54b9d160 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableUnits.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableUnits.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataControlledVariableUnits interface {
IBACnetConstructedData
// GetUnits returns Units (property field)
GetUnits() *BACnetEngineeringUnitsTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetEngineeringUnitsTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataControlledVariableUnits) GetUnits() *BACnetEnginee
return m.Units
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataControlledVariableUnits) GetActualValue() *BACnetEngineeringUnitsTagged {
+ return CastBACnetEngineeringUnitsTagged(m.GetUnits())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataControlledVariableUnits) GetLengthInBitsConditiona
// Simple field (units)
lengthInBits += m.Units.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataControlledVariableUnitsParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for units")
}
+ // Virtual field
+ _actualValue := units
+ actualValue := CastBACnetEngineeringUnitsTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataControlledVariableUnits"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataControlledVariableUnits")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataControlledVariableUnits) Serialize(writeBuffer uti
if _unitsErr != nil {
return errors.Wrap(_unitsErr, "Error serializing 'units' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataControlledVariableUnits"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataControlledVariableUnits")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableValue.go
index 9997fa75e7..2afc56f118 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataControlledVariableValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataControlledVariableValue interface {
IBACnetConstructedData
// GetControlledVariableValue returns ControlledVariableValue (property field)
GetControlledVariableValue() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataControlledVariableValue) GetControlledVariableValu
return m.ControlledVariableValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataControlledVariableValue) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetControlledVariableValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataControlledVariableValue) GetLengthInBitsConditiona
// Simple field (controlledVariableValue)
lengthInBits += m.ControlledVariableValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataControlledVariableValueParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for controlledVariableValue")
}
+ // Virtual field
+ _actualValue := controlledVariableValue
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataControlledVariableValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataControlledVariableValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataControlledVariableValue) Serialize(writeBuffer uti
if _controlledVariableValueErr != nil {
return errors.Wrap(_controlledVariableValueErr, "Error serializing 'controlledVariableValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataControlledVariableValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataControlledVariableValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCount.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCount.go
index 68cfde6af4..aed77b883d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCount.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCount.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCount interface {
IBACnetConstructedData
// GetCount returns Count (property field)
GetCount() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCount) GetCount() *BACnetApplicationTagUnsignedInt
return m.Count
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCount) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCount())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCount) GetLengthInBitsConditional(lastItem bool) u
// Simple field (count)
lengthInBits += m.Count.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCountParse(readBuffer utils.ReadBuffer, tagNumber uint
return nil, errors.Wrap(closeErr, "Error closing for count")
}
+ // Virtual field
+ _actualValue := count
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCount"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCount")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCount) Serialize(writeBuffer utils.WriteBuffer) er
if _countErr != nil {
return errors.Wrap(_countErr, "Error serializing 'count' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCount"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCount")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountBeforeChange.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountBeforeChange.go
index d7f685055e..2e78052f0d 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountBeforeChange.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountBeforeChange.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCountBeforeChange interface {
IBACnetConstructedData
// GetCountBeforeChange returns CountBeforeChange (property field)
GetCountBeforeChange() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCountBeforeChange) GetCountBeforeChange() *BACnetA
return m.CountBeforeChange
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCountBeforeChange) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetCountBeforeChange())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCountBeforeChange) GetLengthInBitsConditional(last
// Simple field (countBeforeChange)
lengthInBits += m.CountBeforeChange.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCountBeforeChangeParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for countBeforeChange")
}
+ // Virtual field
+ _actualValue := countBeforeChange
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCountBeforeChange"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCountBeforeChange")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCountBeforeChange) Serialize(writeBuffer utils.Wri
if _countBeforeChangeErr != nil {
return errors.Wrap(_countBeforeChangeErr, "Error serializing 'countBeforeChange' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCountBeforeChange"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCountBeforeChange")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountChangeTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountChangeTime.go
index fcb0f09016..45708b9f87 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountChangeTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCountChangeTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCountChangeTime interface {
IBACnetConstructedData
// GetCountChangeTime returns CountChangeTime (property field)
GetCountChangeTime() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCountChangeTime) GetCountChangeTime() *BACnetDateT
return m.CountChangeTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCountChangeTime) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetCountChangeTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCountChangeTime) GetLengthInBitsConditional(lastIt
// Simple field (countChangeTime)
lengthInBits += m.CountChangeTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCountChangeTimeParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for countChangeTime")
}
+ // Virtual field
+ _actualValue := countChangeTime
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCountChangeTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCountChangeTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCountChangeTime) Serialize(writeBuffer utils.Write
if _countChangeTimeErr != nil {
return errors.Wrap(_countChangeTimeErr, "Error serializing 'countChangeTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCountChangeTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCountChangeTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputPresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputPresentValue.go
index 593bb21d99..3bd520d413 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputPresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputPresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCredentialDataInputPresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetAuthenticationFactor
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetAuthenticationFactor
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCredentialDataInputPresentValue) GetPresentValue()
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCredentialDataInputPresentValue) GetActualValue() *BACnetAuthenticationFactor {
+ return CastBACnetAuthenticationFactor(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCredentialDataInputPresentValue) GetLengthInBitsCo
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCredentialDataInputPresentValueParse(readBuffer utils.
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetAuthenticationFactor(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCredentialDataInputPresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCredentialDataInputPresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCredentialDataInputPresentValue) Serialize(writeBu
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCredentialDataInputPresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCredentialDataInputPresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputUpdateTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputUpdateTime.go
index 4622f7f147..c4b8a241d0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputUpdateTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDataInputUpdateTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCredentialDataInputUpdateTime interface {
IBACnetConstructedData
// GetUpdateTime returns UpdateTime (property field)
GetUpdateTime() *BACnetTimeStamp
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetTimeStamp
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCredentialDataInputUpdateTime) GetUpdateTime() *BA
return m.UpdateTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCredentialDataInputUpdateTime) GetActualValue() *BACnetTimeStamp {
+ return CastBACnetTimeStamp(m.GetUpdateTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCredentialDataInputUpdateTime) GetLengthInBitsCond
// Simple field (updateTime)
lengthInBits += m.UpdateTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCredentialDataInputUpdateTimeParse(readBuffer utils.Re
return nil, errors.Wrap(closeErr, "Error closing for updateTime")
}
+ // Virtual field
+ _actualValue := updateTime
+ actualValue := CastBACnetTimeStamp(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCredentialDataInputUpdateTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCredentialDataInputUpdateTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCredentialDataInputUpdateTime) Serialize(writeBuff
if _updateTimeErr != nil {
return errors.Wrap(_updateTimeErr, "Error serializing 'updateTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCredentialDataInputUpdateTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCredentialDataInputUpdateTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDisable.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDisable.go
index 58621c0ae0..f7d3f6d304 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDisable.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialDisable.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCredentialDisable interface {
IBACnetConstructedData
// GetCredentialDisable returns CredentialDisable (property field)
GetCredentialDisable() *BACnetAccessCredentialDisableTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetAccessCredentialDisableTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCredentialDisable) GetCredentialDisable() *BACnetA
return m.CredentialDisable
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCredentialDisable) GetActualValue() *BACnetAccessCredentialDisableTagged {
+ return CastBACnetAccessCredentialDisableTagged(m.GetCredentialDisable())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCredentialDisable) GetLengthInBitsConditional(last
// Simple field (credentialDisable)
lengthInBits += m.CredentialDisable.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCredentialDisableParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for credentialDisable")
}
+ // Virtual field
+ _actualValue := credentialDisable
+ actualValue := CastBACnetAccessCredentialDisableTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCredentialDisable"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCredentialDisable")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCredentialDisable) Serialize(writeBuffer utils.Wri
if _credentialDisableErr != nil {
return errors.Wrap(_credentialDisableErr, "Error serializing 'credentialDisable' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCredentialDisable"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCredentialDisable")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialStatus.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialStatus.go
index 7f421a84f6..395d2ac939 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialStatus.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentialStatus.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCredentialStatus interface {
IBACnetConstructedData
// GetBinaryPv returns BinaryPv (property field)
GetBinaryPv() *BACnetBinaryPVTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetBinaryPVTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCredentialStatus) GetBinaryPv() *BACnetBinaryPVTag
return m.BinaryPv
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCredentialStatus) GetActualValue() *BACnetBinaryPVTagged {
+ return CastBACnetBinaryPVTagged(m.GetBinaryPv())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCredentialStatus) GetLengthInBitsConditional(lastI
// Simple field (binaryPv)
lengthInBits += m.BinaryPv.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCredentialStatusParse(readBuffer utils.ReadBuffer, tag
return nil, errors.Wrap(closeErr, "Error closing for binaryPv")
}
+ // Virtual field
+ _actualValue := binaryPv
+ actualValue := CastBACnetBinaryPVTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCredentialStatus"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCredentialStatus")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCredentialStatus) Serialize(writeBuffer utils.Writ
if _binaryPvErr != nil {
return errors.Wrap(_binaryPvErr, "Error serializing 'binaryPv' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCredentialStatus"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCredentialStatus")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCurrentCommandPriority.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCurrentCommandPriority.go
index 3d8afb8e5b..7d79f70137 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCurrentCommandPriority.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCurrentCommandPriority.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataCurrentCommandPriority interface {
IBACnetConstructedData
// GetCurrentCommandPriority returns CurrentCommandPriority (property field)
GetCurrentCommandPriority() *BACnetOptionalUnsigned
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetOptionalUnsigned
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataCurrentCommandPriority) GetCurrentCommandPriority(
return m.CurrentCommandPriority
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCurrentCommandPriority) GetActualValue() *BACnetOptionalUnsigned {
+ return CastBACnetOptionalUnsigned(m.GetCurrentCommandPriority())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataCurrentCommandPriority) GetLengthInBitsConditional
// Simple field (currentCommandPriority)
lengthInBits += m.CurrentCommandPriority.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataCurrentCommandPriorityParse(readBuffer utils.ReadBuffe
return nil, errors.Wrap(closeErr, "Error closing for currentCommandPriority")
}
+ // Virtual field
+ _actualValue := currentCommandPriority
+ actualValue := CastBACnetOptionalUnsigned(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataCurrentCommandPriority"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataCurrentCommandPriority")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataCurrentCommandPriority) Serialize(writeBuffer util
if _currentCommandPriorityErr != nil {
return errors.Wrap(_currentCommandPriorityErr, "Error serializing 'currentCommandPriority' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataCurrentCommandPriority"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataCurrentCommandPriority")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatabaseRevision.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatabaseRevision.go
index 35b6d509bf..7b3678486b 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatabaseRevision.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatabaseRevision.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDatabaseRevision interface {
IBACnetConstructedData
// GetDatabaseRevision returns DatabaseRevision (property field)
GetDatabaseRevision() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDatabaseRevision) GetDatabaseRevision() *BACnetApp
return m.DatabaseRevision
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDatabaseRevision) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetDatabaseRevision())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDatabaseRevision) GetLengthInBitsConditional(lastI
// Simple field (databaseRevision)
lengthInBits += m.DatabaseRevision.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDatabaseRevisionParse(readBuffer utils.ReadBuffer, tag
return nil, errors.Wrap(closeErr, "Error closing for databaseRevision")
}
+ // Virtual field
+ _actualValue := databaseRevision
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDatabaseRevision"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDatabaseRevision")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDatabaseRevision) Serialize(writeBuffer utils.Writ
if _databaseRevisionErr != nil {
return errors.Wrap(_databaseRevisionErr, "Error serializing 'databaseRevision' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDatabaseRevision"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDatabaseRevision")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValuePresentValue.go
index d45bf8e881..37c842c583 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDatePatternValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagDate
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagDate
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDatePatternValuePresentValue) GetPresentValue() *B
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDatePatternValuePresentValue) GetActualValue() *BACnetApplicationTagDate {
+ return CastBACnetApplicationTagDate(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDatePatternValuePresentValue) GetLengthInBitsCondi
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDatePatternValuePresentValueParse(readBuffer utils.Rea
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagDate(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDatePatternValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDatePatternValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDatePatternValuePresentValue) Serialize(writeBuffe
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDatePatternValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDatePatternValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValueRelinquishDefault.go
index a97a9f8f39..ee04ac488c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDatePatternValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDatePatternValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagDate
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagDate
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDatePatternValueRelinquishDefault) GetRelinquishDe
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDatePatternValueRelinquishDefault) GetActualValue() *BACnetApplicationTagDate {
+ return CastBACnetApplicationTagDate(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDatePatternValueRelinquishDefault) GetLengthInBits
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDatePatternValueRelinquishDefaultParse(readBuffer util
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagDate(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDatePatternValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDatePatternValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDatePatternValueRelinquishDefault) Serialize(write
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDatePatternValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDatePatternValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValuePresentValue.go
index 9078c6aed0..8052e8b797 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateTimePatternValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateTimePatternValuePresentValue) GetPresentValue(
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateTimePatternValuePresentValue) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateTimePatternValuePresentValue) GetLengthInBitsC
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateTimePatternValuePresentValueParse(readBuffer utils
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateTimePatternValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateTimePatternValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateTimePatternValuePresentValue) Serialize(writeB
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateTimePatternValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateTimePatternValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValueRelinquishDefault.go
index aabebf2d3e..4056766fbd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimePatternValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateTimePatternValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateTimePatternValueRelinquishDefault) GetRelinqui
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateTimePatternValueRelinquishDefault) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateTimePatternValueRelinquishDefault) GetLengthIn
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateTimePatternValueRelinquishDefaultParse(readBuffer
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateTimePatternValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateTimePatternValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateTimePatternValueRelinquishDefault) Serialize(w
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateTimePatternValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateTimePatternValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValuePresentValue.go
index a929d0181f..76cb9b6c9c 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateTimeValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateTimeValuePresentValue) GetPresentValue() *BACn
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateTimeValuePresentValue) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateTimeValuePresentValue) GetLengthInBitsConditio
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateTimeValuePresentValueParse(readBuffer utils.ReadBu
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateTimeValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateTimeValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateTimeValuePresentValue) Serialize(writeBuffer u
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateTimeValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateTimeValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValueRelinquishDefault.go
index 13c8c79678..e826512197 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateTimeValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateTimeValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetDateTime
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDateTime
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateTimeValueRelinquishDefault) GetRelinquishDefau
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateTimeValueRelinquishDefault) GetActualValue() *BACnetDateTime {
+ return CastBACnetDateTime(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateTimeValueRelinquishDefault) GetLengthInBitsCon
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateTimeValueRelinquishDefaultParse(readBuffer utils.R
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetDateTime(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateTimeValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateTimeValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateTimeValueRelinquishDefault) Serialize(writeBuf
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateTimeValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateTimeValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValuePresentValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValuePresentValue.go
index 04b24c2cc4..17c9654000 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValuePresentValue.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValuePresentValue.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateValuePresentValue interface {
IBACnetConstructedData
// GetPresentValue returns PresentValue (property field)
GetPresentValue() *BACnetApplicationTagDate
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagDate
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateValuePresentValue) GetPresentValue() *BACnetAp
return m.PresentValue
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateValuePresentValue) GetActualValue() *BACnetApplicationTagDate {
+ return CastBACnetApplicationTagDate(m.GetPresentValue())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateValuePresentValue) GetLengthInBitsConditional(
// Simple field (presentValue)
lengthInBits += m.PresentValue.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateValuePresentValueParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for presentValue")
}
+ // Virtual field
+ _actualValue := presentValue
+ actualValue := CastBACnetApplicationTagDate(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateValuePresentValue"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateValuePresentValue")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateValuePresentValue) Serialize(writeBuffer utils
if _presentValueErr != nil {
return errors.Wrap(_presentValueErr, "Error serializing 'presentValue' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateValuePresentValue"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateValuePresentValue")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValueRelinquishDefault.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValueRelinquishDefault.go
index 5de8fcaf48..af997a3dac 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValueRelinquishDefault.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDateValueRelinquishDefault.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDateValueRelinquishDefault interface {
IBACnetConstructedData
// GetRelinquishDefault returns RelinquishDefault (property field)
GetRelinquishDefault() *BACnetApplicationTagDate
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagDate
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDateValueRelinquishDefault) GetRelinquishDefault()
return m.RelinquishDefault
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDateValueRelinquishDefault) GetActualValue() *BACnetApplicationTagDate {
+ return CastBACnetApplicationTagDate(m.GetRelinquishDefault())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDateValueRelinquishDefault) GetLengthInBitsConditi
// Simple field (relinquishDefault)
lengthInBits += m.RelinquishDefault.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDateValueRelinquishDefaultParse(readBuffer utils.ReadB
return nil, errors.Wrap(closeErr, "Error closing for relinquishDefault")
}
+ // Virtual field
+ _actualValue := relinquishDefault
+ actualValue := CastBACnetApplicationTagDate(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDateValueRelinquishDefault"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDateValueRelinquishDefault")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDateValueRelinquishDefault) Serialize(writeBuffer
if _relinquishDefaultErr != nil {
return errors.Wrap(_relinquishDefaultErr, "Error serializing 'relinquishDefault' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDateValueRelinquishDefault"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDateValueRelinquishDefault")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaylightSavingsStatus.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaylightSavingsStatus.go
index 492dd063b9..467d277fbb 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaylightSavingsStatus.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaylightSavingsStatus.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDaylightSavingsStatus interface {
IBACnetConstructedData
// GetDaylightSavingsStatus returns DaylightSavingsStatus (property field)
GetDaylightSavingsStatus() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDaylightSavingsStatus) GetDaylightSavingsStatus()
return m.DaylightSavingsStatus
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDaylightSavingsStatus) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetDaylightSavingsStatus())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDaylightSavingsStatus) GetLengthInBitsConditional(
// Simple field (daylightSavingsStatus)
lengthInBits += m.DaylightSavingsStatus.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDaylightSavingsStatusParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for daylightSavingsStatus")
}
+ // Virtual field
+ _actualValue := daylightSavingsStatus
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDaylightSavingsStatus"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDaylightSavingsStatus")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDaylightSavingsStatus) Serialize(writeBuffer utils
if _daylightSavingsStatusErr != nil {
return errors.Wrap(_daylightSavingsStatusErr, "Error serializing 'daylightSavingsStatus' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDaylightSavingsStatus"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDaylightSavingsStatus")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaysRemaining.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaysRemaining.go
index 80480ef36f..85f1909c55 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaysRemaining.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDaysRemaining.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDaysRemaining interface {
IBACnetConstructedData
// GetDaysRemaining returns DaysRemaining (property field)
GetDaysRemaining() *BACnetApplicationTagSignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagSignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDaysRemaining) GetDaysRemaining() *BACnetApplicati
return m.DaysRemaining
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDaysRemaining) GetActualValue() *BACnetApplicationTagSignedInteger {
+ return CastBACnetApplicationTagSignedInteger(m.GetDaysRemaining())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDaysRemaining) GetLengthInBitsConditional(lastItem
// Simple field (daysRemaining)
lengthInBits += m.DaysRemaining.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDaysRemainingParse(readBuffer utils.ReadBuffer, tagNum
return nil, errors.Wrap(closeErr, "Error closing for daysRemaining")
}
+ // Virtual field
+ _actualValue := daysRemaining
+ actualValue := CastBACnetApplicationTagSignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDaysRemaining"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDaysRemaining")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDaysRemaining) Serialize(writeBuffer utils.WriteBu
if _daysRemainingErr != nil {
return errors.Wrap(_daysRemainingErr, "Error serializing 'daysRemaining' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDaysRemaining"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDaysRemaining")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeadband.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeadband.go
index e4f6adc906..2048e95639 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeadband.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeadband.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDeadband interface {
IBACnetConstructedData
// GetDeadband returns Deadband (property field)
GetDeadband() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDeadband) GetDeadband() *BACnetApplicationTagReal
return m.Deadband
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDeadband) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetDeadband())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDeadband) GetLengthInBitsConditional(lastItem bool
// Simple field (deadband)
lengthInBits += m.Deadband.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDeadbandParse(readBuffer utils.ReadBuffer, tagNumber u
return nil, errors.Wrap(closeErr, "Error closing for deadband")
}
+ // Virtual field
+ _actualValue := deadband
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDeadband"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDeadband")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDeadband) Serialize(writeBuffer utils.WriteBuffer)
if _deadbandErr != nil {
return errors.Wrap(_deadbandErr, "Error serializing 'deadband' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDeadband"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDeadband")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultFadeTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultFadeTime.go
index 814aa07743..7c8fb48cf5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultFadeTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultFadeTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDefaultFadeTime interface {
IBACnetConstructedData
// GetDefaultFadeTime returns DefaultFadeTime (property field)
GetDefaultFadeTime() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDefaultFadeTime) GetDefaultFadeTime() *BACnetAppli
return m.DefaultFadeTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDefaultFadeTime) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetDefaultFadeTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDefaultFadeTime) GetLengthInBitsConditional(lastIt
// Simple field (defaultFadeTime)
lengthInBits += m.DefaultFadeTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDefaultFadeTimeParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for defaultFadeTime")
}
+ // Virtual field
+ _actualValue := defaultFadeTime
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDefaultFadeTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDefaultFadeTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDefaultFadeTime) Serialize(writeBuffer utils.Write
if _defaultFadeTimeErr != nil {
return errors.Wrap(_defaultFadeTimeErr, "Error serializing 'defaultFadeTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDefaultFadeTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDefaultFadeTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultRampRate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultRampRate.go
index eab7b57a03..25bfa08c42 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultRampRate.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultRampRate.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDefaultRampRate interface {
IBACnetConstructedData
// GetDefaultRampRate returns DefaultRampRate (property field)
GetDefaultRampRate() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDefaultRampRate) GetDefaultRampRate() *BACnetAppli
return m.DefaultRampRate
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDefaultRampRate) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetDefaultRampRate())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDefaultRampRate) GetLengthInBitsConditional(lastIt
// Simple field (defaultRampRate)
lengthInBits += m.DefaultRampRate.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDefaultRampRateParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for defaultRampRate")
}
+ // Virtual field
+ _actualValue := defaultRampRate
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDefaultRampRate"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDefaultRampRate")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDefaultRampRate) Serialize(writeBuffer utils.Write
if _defaultRampRateErr != nil {
return errors.Wrap(_defaultRampRateErr, "Error serializing 'defaultRampRate' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDefaultRampRate"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDefaultRampRate")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultStepIncrement.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultStepIncrement.go
index 021bad3045..174df000a0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultStepIncrement.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultStepIncrement.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDefaultStepIncrement interface {
IBACnetConstructedData
// GetDefaultStepIncrement returns DefaultStepIncrement (property field)
GetDefaultStepIncrement() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDefaultStepIncrement) GetDefaultStepIncrement() *B
return m.DefaultStepIncrement
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDefaultStepIncrement) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetDefaultStepIncrement())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDefaultStepIncrement) GetLengthInBitsConditional(l
// Simple field (defaultStepIncrement)
lengthInBits += m.DefaultStepIncrement.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDefaultStepIncrementParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for defaultStepIncrement")
}
+ // Virtual field
+ _actualValue := defaultStepIncrement
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDefaultStepIncrement"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDefaultStepIncrement")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDefaultStepIncrement) Serialize(writeBuffer utils.
if _defaultStepIncrementErr != nil {
return errors.Wrap(_defaultStepIncrementErr, "Error serializing 'defaultStepIncrement' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDefaultStepIncrement"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDefaultStepIncrement")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultSubordinateRelationship.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultSubordinateRelationship.go
index b202cbed52..8bc017242f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultSubordinateRelationship.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultSubordinateRelationship.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDefaultSubordinateRelationship interface {
IBACnetConstructedData
// GetDefaultSubordinateRelationship returns DefaultSubordinateRelationship (property field)
GetDefaultSubordinateRelationship() *BACnetRelationshipTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetRelationshipTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDefaultSubordinateRelationship) GetDefaultSubordin
return m.DefaultSubordinateRelationship
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDefaultSubordinateRelationship) GetActualValue() *BACnetRelationshipTagged {
+ return CastBACnetRelationshipTagged(m.GetDefaultSubordinateRelationship())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDefaultSubordinateRelationship) GetLengthInBitsCon
// Simple field (defaultSubordinateRelationship)
lengthInBits += m.DefaultSubordinateRelationship.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDefaultSubordinateRelationshipParse(readBuffer utils.R
return nil, errors.Wrap(closeErr, "Error closing for defaultSubordinateRelationship")
}
+ // Virtual field
+ _actualValue := defaultSubordinateRelationship
+ actualValue := CastBACnetRelationshipTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDefaultSubordinateRelationship"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDefaultSubordinateRelationship")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDefaultSubordinateRelationship) Serialize(writeBuf
if _defaultSubordinateRelationshipErr != nil {
return errors.Wrap(_defaultSubordinateRelationshipErr, "Error serializing 'defaultSubordinateRelationship' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDefaultSubordinateRelationship"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDefaultSubordinateRelationship")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultTimeout.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultTimeout.go
index 3576bc99f7..1aa86151a0 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultTimeout.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDefaultTimeout.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDefaultTimeout interface {
IBACnetConstructedData
// GetDefaultTimeout returns DefaultTimeout (property field)
GetDefaultTimeout() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDefaultTimeout) GetDefaultTimeout() *BACnetApplica
return m.DefaultTimeout
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDefaultTimeout) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetDefaultTimeout())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDefaultTimeout) GetLengthInBitsConditional(lastIte
// Simple field (defaultTimeout)
lengthInBits += m.DefaultTimeout.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDefaultTimeoutParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for defaultTimeout")
}
+ // Virtual field
+ _actualValue := defaultTimeout
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDefaultTimeout"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDefaultTimeout")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDefaultTimeout) Serialize(writeBuffer utils.WriteB
if _defaultTimeoutErr != nil {
return errors.Wrap(_defaultTimeoutErr, "Error serializing 'defaultTimeout' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDefaultTimeout"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDefaultTimeout")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeployedProfileLocation.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeployedProfileLocation.go
index 3842fa7a70..1e87fbed27 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeployedProfileLocation.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeployedProfileLocation.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDeployedProfileLocation interface {
IBACnetConstructedData
// GetDeployedProfileLocation returns DeployedProfileLocation (property field)
GetDeployedProfileLocation() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDeployedProfileLocation) GetDeployedProfileLocatio
return m.DeployedProfileLocation
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDeployedProfileLocation) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetDeployedProfileLocation())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDeployedProfileLocation) GetLengthInBitsConditiona
// Simple field (deployedProfileLocation)
lengthInBits += m.DeployedProfileLocation.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDeployedProfileLocationParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for deployedProfileLocation")
}
+ // Virtual field
+ _actualValue := deployedProfileLocation
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDeployedProfileLocation"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDeployedProfileLocation")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDeployedProfileLocation) Serialize(writeBuffer uti
if _deployedProfileLocationErr != nil {
return errors.Wrap(_deployedProfileLocationErr, "Error serializing 'deployedProfileLocation' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDeployedProfileLocation"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDeployedProfileLocation")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstant.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstant.go
index 426f756667..e8f33bb5bd 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstant.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstant.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDerivativeConstant interface {
IBACnetConstructedData
// GetDerivativeConstant returns DerivativeConstant (property field)
GetDerivativeConstant() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDerivativeConstant) GetDerivativeConstant() *BACne
return m.DerivativeConstant
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDerivativeConstant) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetDerivativeConstant())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDerivativeConstant) GetLengthInBitsConditional(las
// Simple field (derivativeConstant)
lengthInBits += m.DerivativeConstant.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDerivativeConstantParse(readBuffer utils.ReadBuffer, t
return nil, errors.Wrap(closeErr, "Error closing for derivativeConstant")
}
+ // Virtual field
+ _actualValue := derivativeConstant
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDerivativeConstant"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDerivativeConstant")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDerivativeConstant) Serialize(writeBuffer utils.Wr
if _derivativeConstantErr != nil {
return errors.Wrap(_derivativeConstantErr, "Error serializing 'derivativeConstant' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDerivativeConstant"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDerivativeConstant")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstantUnits.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstantUnits.go
index af5ddced8c..1f39f29c0e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstantUnits.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDerivativeConstantUnits.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDerivativeConstantUnits interface {
IBACnetConstructedData
// GetUnits returns Units (property field)
GetUnits() *BACnetEngineeringUnitsTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetEngineeringUnitsTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDerivativeConstantUnits) GetUnits() *BACnetEnginee
return m.Units
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDerivativeConstantUnits) GetActualValue() *BACnetEngineeringUnitsTagged {
+ return CastBACnetEngineeringUnitsTagged(m.GetUnits())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDerivativeConstantUnits) GetLengthInBitsConditiona
// Simple field (units)
lengthInBits += m.Units.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDerivativeConstantUnitsParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for units")
}
+ // Virtual field
+ _actualValue := units
+ actualValue := CastBACnetEngineeringUnitsTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDerivativeConstantUnits"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDerivativeConstantUnits")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDerivativeConstantUnits) Serialize(writeBuffer uti
if _unitsErr != nil {
return errors.Wrap(_unitsErr, "Error serializing 'units' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDerivativeConstantUnits"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDerivativeConstantUnits")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescription.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescription.go
index afc35ae6ff..f848df713e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescription.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescription.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDescription interface {
IBACnetConstructedData
// GetDescription returns Description (property field)
GetDescription() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDescription) GetDescription() *BACnetApplicationTa
return m.Description
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDescription) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetDescription())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDescription) GetLengthInBitsConditional(lastItem b
// Simple field (description)
lengthInBits += m.Description.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDescriptionParse(readBuffer utils.ReadBuffer, tagNumbe
return nil, errors.Wrap(closeErr, "Error closing for description")
}
+ // Virtual field
+ _actualValue := description
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDescription"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDescription")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDescription) Serialize(writeBuffer utils.WriteBuff
if _descriptionErr != nil {
return errors.Wrap(_descriptionErr, "Error serializing 'description' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDescription"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDescription")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescriptionOfHalt.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescriptionOfHalt.go
index 431fe05d65..97658f3fd5 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescriptionOfHalt.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDescriptionOfHalt.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDescriptionOfHalt interface {
IBACnetConstructedData
// GetDescriptionForHalt returns DescriptionForHalt (property field)
GetDescriptionForHalt() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDescriptionOfHalt) GetDescriptionForHalt() *BACnet
return m.DescriptionForHalt
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDescriptionOfHalt) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetDescriptionForHalt())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDescriptionOfHalt) GetLengthInBitsConditional(last
// Simple field (descriptionForHalt)
lengthInBits += m.DescriptionForHalt.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDescriptionOfHaltParse(readBuffer utils.ReadBuffer, ta
return nil, errors.Wrap(closeErr, "Error closing for descriptionForHalt")
}
+ // Virtual field
+ _actualValue := descriptionForHalt
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDescriptionOfHalt"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDescriptionOfHalt")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDescriptionOfHalt) Serialize(writeBuffer utils.Wri
if _descriptionForHaltErr != nil {
return errors.Wrap(_descriptionForHaltErr, "Error serializing 'descriptionForHalt' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDescriptionOfHalt"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDescriptionOfHalt")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxInfoFrames.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxInfoFrames.go
index 8e14b96e6a..edc916c601 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxInfoFrames.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxInfoFrames.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDeviceMaxInfoFrames interface {
IBACnetConstructedData
// GetMaxInfoFrames returns MaxInfoFrames (property field)
GetMaxInfoFrames() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDeviceMaxInfoFrames) GetMaxInfoFrames() *BACnetApp
return m.MaxInfoFrames
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDeviceMaxInfoFrames) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetMaxInfoFrames())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDeviceMaxInfoFrames) GetLengthInBitsConditional(la
// Simple field (maxInfoFrames)
lengthInBits += m.MaxInfoFrames.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDeviceMaxInfoFramesParse(readBuffer utils.ReadBuffer,
return nil, errors.Wrap(closeErr, "Error closing for maxInfoFrames")
}
+ // Virtual field
+ _actualValue := maxInfoFrames
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDeviceMaxInfoFrames"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDeviceMaxInfoFrames")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDeviceMaxInfoFrames) Serialize(writeBuffer utils.W
if _maxInfoFramesErr != nil {
return errors.Wrap(_maxInfoFramesErr, "Error serializing 'maxInfoFrames' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDeviceMaxInfoFrames"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDeviceMaxInfoFrames")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxMaster.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxMaster.go
index b5f8eb14a3..4c780cdf97 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxMaster.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceMaxMaster.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDeviceMaxMaster interface {
IBACnetConstructedData
// GetMaxMaster returns MaxMaster (property field)
GetMaxMaster() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDeviceMaxMaster) GetMaxMaster() *BACnetApplication
return m.MaxMaster
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDeviceMaxMaster) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetMaxMaster())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDeviceMaxMaster) GetLengthInBitsConditional(lastIt
// Simple field (maxMaster)
lengthInBits += m.MaxMaster.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDeviceMaxMasterParse(readBuffer utils.ReadBuffer, tagN
return nil, errors.Wrap(closeErr, "Error closing for maxMaster")
}
+ // Virtual field
+ _actualValue := maxMaster
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDeviceMaxMaster"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDeviceMaxMaster")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDeviceMaxMaster) Serialize(writeBuffer utils.Write
if _maxMasterErr != nil {
return errors.Wrap(_maxMasterErr, "Error serializing 'maxMaster' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDeviceMaxMaster"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDeviceMaxMaster")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceType.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceType.go
index c03930f4b3..b8626e2d02 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceType.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDeviceType.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDeviceType interface {
IBACnetConstructedData
// GetDeviceType returns DeviceType (property field)
GetDeviceType() *BACnetApplicationTagCharacterString
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagCharacterString
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDeviceType) GetDeviceType() *BACnetApplicationTagC
return m.DeviceType
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDeviceType) GetActualValue() *BACnetApplicationTagCharacterString {
+ return CastBACnetApplicationTagCharacterString(m.GetDeviceType())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDeviceType) GetLengthInBitsConditional(lastItem bo
// Simple field (deviceType)
lengthInBits += m.DeviceType.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDeviceTypeParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for deviceType")
}
+ // Virtual field
+ _actualValue := deviceType
+ actualValue := CastBACnetApplicationTagCharacterString(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDeviceType"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDeviceType")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDeviceType) Serialize(writeBuffer utils.WriteBuffe
if _deviceTypeErr != nil {
return errors.Wrap(_deviceTypeErr, "Error serializing 'deviceType' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDeviceType"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDeviceType")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDirectReading.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDirectReading.go
index d45b676854..7baaf0717f 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDirectReading.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDirectReading.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDirectReading interface {
IBACnetConstructedData
// GetDirectReading returns DirectReading (property field)
GetDirectReading() *BACnetApplicationTagReal
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagReal
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDirectReading) GetDirectReading() *BACnetApplicati
return m.DirectReading
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDirectReading) GetActualValue() *BACnetApplicationTagReal {
+ return CastBACnetApplicationTagReal(m.GetDirectReading())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDirectReading) GetLengthInBitsConditional(lastItem
// Simple field (directReading)
lengthInBits += m.DirectReading.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDirectReadingParse(readBuffer utils.ReadBuffer, tagNum
return nil, errors.Wrap(closeErr, "Error closing for directReading")
}
+ // Virtual field
+ _actualValue := directReading
+ actualValue := CastBACnetApplicationTagReal(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDirectReading"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDirectReading")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDirectReading) Serialize(writeBuffer utils.WriteBu
if _directReadingErr != nil {
return errors.Wrap(_directReadingErr, "Error serializing 'directReading' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDirectReading"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDirectReading")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDistributionKeyRevision.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDistributionKeyRevision.go
index f242e09528..899cc04ea3 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDistributionKeyRevision.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDistributionKeyRevision.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDistributionKeyRevision interface {
IBACnetConstructedData
// GetDistributionKeyRevision returns DistributionKeyRevision (property field)
GetDistributionKeyRevision() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDistributionKeyRevision) GetDistributionKeyRevisio
return m.DistributionKeyRevision
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDistributionKeyRevision) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetDistributionKeyRevision())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDistributionKeyRevision) GetLengthInBitsConditiona
// Simple field (distributionKeyRevision)
lengthInBits += m.DistributionKeyRevision.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDistributionKeyRevisionParse(readBuffer utils.ReadBuff
return nil, errors.Wrap(closeErr, "Error closing for distributionKeyRevision")
}
+ // Virtual field
+ _actualValue := distributionKeyRevision
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDistributionKeyRevision"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDistributionKeyRevision")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDistributionKeyRevision) Serialize(writeBuffer uti
if _distributionKeyRevisionErr != nil {
return errors.Wrap(_distributionKeyRevisionErr, "Error serializing 'distributionKeyRevision' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDistributionKeyRevision"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDistributionKeyRevision")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoNotHide.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoNotHide.go
index 2956d8347b..787536850e 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoNotHide.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoNotHide.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDoNotHide interface {
IBACnetConstructedData
// GetDoNotHide returns DoNotHide (property field)
GetDoNotHide() *BACnetApplicationTagBoolean
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagBoolean
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDoNotHide) GetDoNotHide() *BACnetApplicationTagBoo
return m.DoNotHide
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDoNotHide) GetActualValue() *BACnetApplicationTagBoolean {
+ return CastBACnetApplicationTagBoolean(m.GetDoNotHide())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDoNotHide) GetLengthInBitsConditional(lastItem boo
// Simple field (doNotHide)
lengthInBits += m.DoNotHide.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDoNotHideParse(readBuffer utils.ReadBuffer, tagNumber
return nil, errors.Wrap(closeErr, "Error closing for doNotHide")
}
+ // Virtual field
+ _actualValue := doNotHide
+ actualValue := CastBACnetApplicationTagBoolean(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDoNotHide"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDoNotHide")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDoNotHide) Serialize(writeBuffer utils.WriteBuffer
if _doNotHideErr != nil {
return errors.Wrap(_doNotHideErr, "Error serializing 'doNotHide' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDoNotHide"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDoNotHide")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorAlarmState.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorAlarmState.go
index 30c2524048..a1518753e8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorAlarmState.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorAlarmState.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDoorAlarmState interface {
IBACnetConstructedData
// GetDoorAlarmState returns DoorAlarmState (property field)
GetDoorAlarmState() *BACnetDoorAlarmStateTagged
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetDoorAlarmStateTagged
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDoorAlarmState) GetDoorAlarmState() *BACnetDoorAla
return m.DoorAlarmState
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDoorAlarmState) GetActualValue() *BACnetDoorAlarmStateTagged {
+ return CastBACnetDoorAlarmStateTagged(m.GetDoorAlarmState())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDoorAlarmState) GetLengthInBitsConditional(lastIte
// Simple field (doorAlarmState)
lengthInBits += m.DoorAlarmState.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDoorAlarmStateParse(readBuffer utils.ReadBuffer, tagNu
return nil, errors.Wrap(closeErr, "Error closing for doorAlarmState")
}
+ // Virtual field
+ _actualValue := doorAlarmState
+ actualValue := CastBACnetDoorAlarmStateTagged(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDoorAlarmState"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDoorAlarmState")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDoorAlarmState) Serialize(writeBuffer utils.WriteB
if _doorAlarmStateErr != nil {
return errors.Wrap(_doorAlarmStateErr, "Error serializing 'doorAlarmState' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDoorAlarmState"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDoorAlarmState")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorExtendedPulseTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorExtendedPulseTime.go
index ed83710383..ec18bfd8c8 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorExtendedPulseTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorExtendedPulseTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDoorExtendedPulseTime interface {
IBACnetConstructedData
// GetDoorExtendedPulseTime returns DoorExtendedPulseTime (property field)
GetDoorExtendedPulseTime() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDoorExtendedPulseTime) GetDoorExtendedPulseTime()
return m.DoorExtendedPulseTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetConstructedDataDoorExtendedPulseTime) GetActualValue() *BACnetApplicationTagUnsignedInteger {
+ return CastBACnetApplicationTagUnsignedInteger(m.GetDoorExtendedPulseTime())
+}
+
///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
@@ -131,6 +146,8 @@ func (m *BACnetConstructedDataDoorExtendedPulseTime) GetLengthInBitsConditional(
// Simple field (doorExtendedPulseTime)
lengthInBits += m.DoorExtendedPulseTime.GetLengthInBits()
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -160,6 +177,11 @@ func BACnetConstructedDataDoorExtendedPulseTimeParse(readBuffer utils.ReadBuffer
return nil, errors.Wrap(closeErr, "Error closing for doorExtendedPulseTime")
}
+ // Virtual field
+ _actualValue := doorExtendedPulseTime
+ actualValue := CastBACnetApplicationTagUnsignedInteger(_actualValue)
+ _ = actualValue
+
if closeErr := readBuffer.CloseContext("BACnetConstructedDataDoorExtendedPulseTime"); closeErr != nil {
return nil, errors.Wrap(closeErr, "Error closing for BACnetConstructedDataDoorExtendedPulseTime")
}
@@ -192,6 +214,10 @@ func (m *BACnetConstructedDataDoorExtendedPulseTime) Serialize(writeBuffer utils
if _doorExtendedPulseTimeErr != nil {
return errors.Wrap(_doorExtendedPulseTimeErr, "Error serializing 'doorExtendedPulseTime' field")
}
+ // Virtual field
+ if _actualValueErr := writeBuffer.WriteVirtual("actualValue", m.GetActualValue()); _actualValueErr != nil {
+ return errors.Wrap(_actualValueErr, "Error serializing 'actualValue' field")
+ }
if popErr := writeBuffer.PopContext("BACnetConstructedDataDoorExtendedPulseTime"); popErr != nil {
return errors.Wrap(popErr, "Error popping for BACnetConstructedDataDoorExtendedPulseTime")
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorOpenTooLongTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorOpenTooLongTime.go
index 47f5b58829..220d2debf2 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorOpenTooLongTime.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataDoorOpenTooLongTime.go
@@ -41,6 +41,8 @@ type IBACnetConstructedDataDoorOpenTooLongTime interface {
IBACnetConstructedData
// GetDoorOpenTooLongTime returns DoorOpenTooLongTime (property field)
GetDoorOpenTooLongTime() *BACnetApplicationTagUnsignedInteger
+ // GetActualValue returns ActualValue (virtual field)
+ GetActualValue() *BACnetApplicationTagUnsignedInteger
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -86,6 +88,19 @@ func (m *BACnetConstructedDataDoorOpenTooLongTime) GetDoorOpenTooLongTime() *BAC
return m.DoorOpenTooLongTime
}
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
... 23975 lines suppressed ...