func()

in v2/api/containerservice/v1api20240402preview/managed_clusters_agent_pool_types_gen.go [1880:2325]
330 lines of code
58 McCabe index (conditional complexity)

func (pool *ManagedClustersAgentPool_Spec) AssignProperties_To_ManagedClustersAgentPool_Spec(destination *storage.ManagedClustersAgentPool_Spec) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// ArtifactStreamingProfile
	if pool.ArtifactStreamingProfile != nil {
		var artifactStreamingProfile storage.AgentPoolArtifactStreamingProfile
		err := pool.ArtifactStreamingProfile.AssignProperties_To_AgentPoolArtifactStreamingProfile(&artifactStreamingProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolArtifactStreamingProfile() to populate field ArtifactStreamingProfile")
		}
		destination.ArtifactStreamingProfile = &artifactStreamingProfile
	} else {
		destination.ArtifactStreamingProfile = nil
	}

	// AvailabilityZones
	destination.AvailabilityZones = genruntime.CloneSliceOfString(pool.AvailabilityZones)

	// AzureName
	destination.AzureName = pool.AzureName

	// CapacityReservationGroupReference
	if pool.CapacityReservationGroupReference != nil {
		capacityReservationGroupReference := pool.CapacityReservationGroupReference.Copy()
		destination.CapacityReservationGroupReference = &capacityReservationGroupReference
	} else {
		destination.CapacityReservationGroupReference = nil
	}

	// Count
	destination.Count = genruntime.ClonePointerToInt(pool.Count)

	// CreationData
	if pool.CreationData != nil {
		var creationDatum storage.CreationData
		err := pool.CreationData.AssignProperties_To_CreationData(&creationDatum)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_CreationData() to populate field CreationData")
		}
		destination.CreationData = &creationDatum
	} else {
		destination.CreationData = nil
	}

	// EnableAutoScaling
	if pool.EnableAutoScaling != nil {
		enableAutoScaling := *pool.EnableAutoScaling
		destination.EnableAutoScaling = &enableAutoScaling
	} else {
		destination.EnableAutoScaling = nil
	}

	// EnableCustomCATrust
	if pool.EnableCustomCATrust != nil {
		enableCustomCATrust := *pool.EnableCustomCATrust
		destination.EnableCustomCATrust = &enableCustomCATrust
	} else {
		destination.EnableCustomCATrust = nil
	}

	// EnableEncryptionAtHost
	if pool.EnableEncryptionAtHost != nil {
		enableEncryptionAtHost := *pool.EnableEncryptionAtHost
		destination.EnableEncryptionAtHost = &enableEncryptionAtHost
	} else {
		destination.EnableEncryptionAtHost = nil
	}

	// EnableFIPS
	if pool.EnableFIPS != nil {
		enableFIPS := *pool.EnableFIPS
		destination.EnableFIPS = &enableFIPS
	} else {
		destination.EnableFIPS = nil
	}

	// EnableNodePublicIP
	if pool.EnableNodePublicIP != nil {
		enableNodePublicIP := *pool.EnableNodePublicIP
		destination.EnableNodePublicIP = &enableNodePublicIP
	} else {
		destination.EnableNodePublicIP = nil
	}

	// EnableUltraSSD
	if pool.EnableUltraSSD != nil {
		enableUltraSSD := *pool.EnableUltraSSD
		destination.EnableUltraSSD = &enableUltraSSD
	} else {
		destination.EnableUltraSSD = nil
	}

	// GatewayProfile
	if pool.GatewayProfile != nil {
		var gatewayProfile storage.AgentPoolGatewayProfile
		err := pool.GatewayProfile.AssignProperties_To_AgentPoolGatewayProfile(&gatewayProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolGatewayProfile() to populate field GatewayProfile")
		}
		destination.GatewayProfile = &gatewayProfile
	} else {
		destination.GatewayProfile = nil
	}

	// GpuInstanceProfile
	if pool.GpuInstanceProfile != nil {
		gpuInstanceProfile := string(*pool.GpuInstanceProfile)
		destination.GpuInstanceProfile = &gpuInstanceProfile
	} else {
		destination.GpuInstanceProfile = nil
	}

	// GpuProfile
	if pool.GpuProfile != nil {
		var gpuProfile storage.AgentPoolGPUProfile
		err := pool.GpuProfile.AssignProperties_To_AgentPoolGPUProfile(&gpuProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolGPUProfile() to populate field GpuProfile")
		}
		destination.GpuProfile = &gpuProfile
	} else {
		destination.GpuProfile = nil
	}

	// HostGroupReference
	if pool.HostGroupReference != nil {
		hostGroupReference := pool.HostGroupReference.Copy()
		destination.HostGroupReference = &hostGroupReference
	} else {
		destination.HostGroupReference = nil
	}

	// KubeletConfig
	if pool.KubeletConfig != nil {
		var kubeletConfig storage.KubeletConfig
		err := pool.KubeletConfig.AssignProperties_To_KubeletConfig(&kubeletConfig)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_KubeletConfig() to populate field KubeletConfig")
		}
		destination.KubeletConfig = &kubeletConfig
	} else {
		destination.KubeletConfig = nil
	}

	// KubeletDiskType
	if pool.KubeletDiskType != nil {
		kubeletDiskType := string(*pool.KubeletDiskType)
		destination.KubeletDiskType = &kubeletDiskType
	} else {
		destination.KubeletDiskType = nil
	}

	// LinuxOSConfig
	if pool.LinuxOSConfig != nil {
		var linuxOSConfig storage.LinuxOSConfig
		err := pool.LinuxOSConfig.AssignProperties_To_LinuxOSConfig(&linuxOSConfig)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_LinuxOSConfig() to populate field LinuxOSConfig")
		}
		destination.LinuxOSConfig = &linuxOSConfig
	} else {
		destination.LinuxOSConfig = nil
	}

	// MaxCount
	destination.MaxCount = genruntime.ClonePointerToInt(pool.MaxCount)

	// MaxPods
	destination.MaxPods = genruntime.ClonePointerToInt(pool.MaxPods)

	// MessageOfTheDay
	destination.MessageOfTheDay = genruntime.ClonePointerToString(pool.MessageOfTheDay)

	// MinCount
	destination.MinCount = genruntime.ClonePointerToInt(pool.MinCount)

	// Mode
	if pool.Mode != nil {
		mode := string(*pool.Mode)
		destination.Mode = &mode
	} else {
		destination.Mode = nil
	}

	// NetworkProfile
	if pool.NetworkProfile != nil {
		var networkProfile storage.AgentPoolNetworkProfile
		err := pool.NetworkProfile.AssignProperties_To_AgentPoolNetworkProfile(&networkProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolNetworkProfile() to populate field NetworkProfile")
		}
		destination.NetworkProfile = &networkProfile
	} else {
		destination.NetworkProfile = nil
	}

	// NodeInitializationTaints
	destination.NodeInitializationTaints = genruntime.CloneSliceOfString(pool.NodeInitializationTaints)

	// NodeLabels
	destination.NodeLabels = genruntime.CloneMapOfStringToString(pool.NodeLabels)

	// NodePublicIPPrefixReference
	if pool.NodePublicIPPrefixReference != nil {
		nodePublicIPPrefixReference := pool.NodePublicIPPrefixReference.Copy()
		destination.NodePublicIPPrefixReference = &nodePublicIPPrefixReference
	} else {
		destination.NodePublicIPPrefixReference = nil
	}

	// NodeTaints
	destination.NodeTaints = genruntime.CloneSliceOfString(pool.NodeTaints)

	// OperatorSpec
	if pool.OperatorSpec != nil {
		var operatorSpec storage.ManagedClustersAgentPoolOperatorSpec
		err := pool.OperatorSpec.AssignProperties_To_ManagedClustersAgentPoolOperatorSpec(&operatorSpec)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_ManagedClustersAgentPoolOperatorSpec() to populate field OperatorSpec")
		}
		destination.OperatorSpec = &operatorSpec
	} else {
		destination.OperatorSpec = nil
	}

	// OrchestratorVersion
	destination.OrchestratorVersion = genruntime.ClonePointerToString(pool.OrchestratorVersion)

	// OriginalVersion
	destination.OriginalVersion = pool.OriginalVersion()

	// OsDiskSizeGB
	if pool.OsDiskSizeGB != nil {
		osDiskSizeGB := int(*pool.OsDiskSizeGB)
		destination.OsDiskSizeGB = &osDiskSizeGB
	} else {
		destination.OsDiskSizeGB = nil
	}

	// OsDiskType
	if pool.OsDiskType != nil {
		osDiskType := string(*pool.OsDiskType)
		destination.OsDiskType = &osDiskType
	} else {
		destination.OsDiskType = nil
	}

	// OsSKU
	if pool.OsSKU != nil {
		osSKU := string(*pool.OsSKU)
		destination.OsSKU = &osSKU
	} else {
		destination.OsSKU = nil
	}

	// OsType
	if pool.OsType != nil {
		osType := string(*pool.OsType)
		destination.OsType = &osType
	} else {
		destination.OsType = nil
	}

	// Owner
	if pool.Owner != nil {
		owner := pool.Owner.Copy()
		destination.Owner = &owner
	} else {
		destination.Owner = nil
	}

	// PodIPAllocationMode
	if pool.PodIPAllocationMode != nil {
		podIPAllocationMode := string(*pool.PodIPAllocationMode)
		destination.PodIPAllocationMode = &podIPAllocationMode
	} else {
		destination.PodIPAllocationMode = nil
	}

	// PodSubnetReference
	if pool.PodSubnetReference != nil {
		podSubnetReference := pool.PodSubnetReference.Copy()
		destination.PodSubnetReference = &podSubnetReference
	} else {
		destination.PodSubnetReference = nil
	}

	// PowerState
	if pool.PowerState != nil {
		var powerState storage.PowerState
		err := pool.PowerState.AssignProperties_To_PowerState(&powerState)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_PowerState() to populate field PowerState")
		}
		destination.PowerState = &powerState
	} else {
		destination.PowerState = nil
	}

	// ProximityPlacementGroupReference
	if pool.ProximityPlacementGroupReference != nil {
		proximityPlacementGroupReference := pool.ProximityPlacementGroupReference.Copy()
		destination.ProximityPlacementGroupReference = &proximityPlacementGroupReference
	} else {
		destination.ProximityPlacementGroupReference = nil
	}

	// ScaleDownMode
	if pool.ScaleDownMode != nil {
		scaleDownMode := string(*pool.ScaleDownMode)
		destination.ScaleDownMode = &scaleDownMode
	} else {
		destination.ScaleDownMode = nil
	}

	// ScaleSetEvictionPolicy
	if pool.ScaleSetEvictionPolicy != nil {
		scaleSetEvictionPolicy := string(*pool.ScaleSetEvictionPolicy)
		destination.ScaleSetEvictionPolicy = &scaleSetEvictionPolicy
	} else {
		destination.ScaleSetEvictionPolicy = nil
	}

	// ScaleSetPriority
	if pool.ScaleSetPriority != nil {
		scaleSetPriority := string(*pool.ScaleSetPriority)
		destination.ScaleSetPriority = &scaleSetPriority
	} else {
		destination.ScaleSetPriority = nil
	}

	// SecurityProfile
	if pool.SecurityProfile != nil {
		var securityProfile storage.AgentPoolSecurityProfile
		err := pool.SecurityProfile.AssignProperties_To_AgentPoolSecurityProfile(&securityProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolSecurityProfile() to populate field SecurityProfile")
		}
		destination.SecurityProfile = &securityProfile
	} else {
		destination.SecurityProfile = nil
	}

	// SpotMaxPrice
	if pool.SpotMaxPrice != nil {
		spotMaxPrice := *pool.SpotMaxPrice
		destination.SpotMaxPrice = &spotMaxPrice
	} else {
		destination.SpotMaxPrice = nil
	}

	// Tags
	destination.Tags = genruntime.CloneMapOfStringToString(pool.Tags)

	// Type
	if pool.Type != nil {
		typeVar := string(*pool.Type)
		destination.Type = &typeVar
	} else {
		destination.Type = nil
	}

	// UpgradeSettings
	if pool.UpgradeSettings != nil {
		var upgradeSetting storage.AgentPoolUpgradeSettings
		err := pool.UpgradeSettings.AssignProperties_To_AgentPoolUpgradeSettings(&upgradeSetting)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolUpgradeSettings() to populate field UpgradeSettings")
		}
		destination.UpgradeSettings = &upgradeSetting
	} else {
		destination.UpgradeSettings = nil
	}

	// VirtualMachineNodesStatus
	if pool.VirtualMachineNodesStatus != nil {
		virtualMachineNodesStatusList := make([]storage.VirtualMachineNodes, len(pool.VirtualMachineNodesStatus))
		for virtualMachineNodesStatusIndex, virtualMachineNodesStatusItem := range pool.VirtualMachineNodesStatus {
			// Shadow the loop variable to avoid aliasing
			virtualMachineNodesStatusItem := virtualMachineNodesStatusItem
			var virtualMachineNodesStatus storage.VirtualMachineNodes
			err := virtualMachineNodesStatusItem.AssignProperties_To_VirtualMachineNodes(&virtualMachineNodesStatus)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_VirtualMachineNodes() to populate field VirtualMachineNodesStatus")
			}
			virtualMachineNodesStatusList[virtualMachineNodesStatusIndex] = virtualMachineNodesStatus
		}
		destination.VirtualMachineNodesStatus = virtualMachineNodesStatusList
	} else {
		destination.VirtualMachineNodesStatus = nil
	}

	// VirtualMachinesProfile
	if pool.VirtualMachinesProfile != nil {
		var virtualMachinesProfile storage.VirtualMachinesProfile
		err := pool.VirtualMachinesProfile.AssignProperties_To_VirtualMachinesProfile(&virtualMachinesProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_VirtualMachinesProfile() to populate field VirtualMachinesProfile")
		}
		destination.VirtualMachinesProfile = &virtualMachinesProfile
	} else {
		destination.VirtualMachinesProfile = nil
	}

	// VmSize
	destination.VmSize = genruntime.ClonePointerToString(pool.VmSize)

	// VnetSubnetReference
	if pool.VnetSubnetReference != nil {
		vnetSubnetReference := pool.VnetSubnetReference.Copy()
		destination.VnetSubnetReference = &vnetSubnetReference
	} else {
		destination.VnetSubnetReference = nil
	}

	// WindowsProfile
	if pool.WindowsProfile != nil {
		var windowsProfile storage.AgentPoolWindowsProfile
		err := pool.WindowsProfile.AssignProperties_To_AgentPoolWindowsProfile(&windowsProfile)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AgentPoolWindowsProfile() to populate field WindowsProfile")
		}
		destination.WindowsProfile = &windowsProfile
	} else {
		destination.WindowsProfile = nil
	}

	// WorkloadRuntime
	if pool.WorkloadRuntime != nil {
		workloadRuntime := string(*pool.WorkloadRuntime)
		destination.WorkloadRuntime = &workloadRuntime
	} else {
		destination.WorkloadRuntime = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}