func()

in v2/api/documentdb/v1api20210515/storage/database_account_types_gen.go [1663:2154]


func (account *DatabaseAccount_STATUS) AssignProperties_To_DatabaseAccount_STATUS(destination *storage.DatabaseAccount_STATUS) error {
	// Clone the existing property bag
	propertyBag := genruntime.NewPropertyBag(account.PropertyBag)

	// AnalyticalStorageConfiguration
	if account.AnalyticalStorageConfiguration != nil {
		var analyticalStorageConfiguration storage.AnalyticalStorageConfiguration_STATUS
		err := account.AnalyticalStorageConfiguration.AssignProperties_To_AnalyticalStorageConfiguration_STATUS(&analyticalStorageConfiguration)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_AnalyticalStorageConfiguration_STATUS() to populate field AnalyticalStorageConfiguration")
		}
		destination.AnalyticalStorageConfiguration = &analyticalStorageConfiguration
	} else {
		destination.AnalyticalStorageConfiguration = nil
	}

	// ApiProperties
	if account.ApiProperties != nil {
		var apiProperty storage.ApiProperties_STATUS
		err := account.ApiProperties.AssignProperties_To_ApiProperties_STATUS(&apiProperty)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_ApiProperties_STATUS() to populate field ApiProperties")
		}
		destination.ApiProperties = &apiProperty
	} else {
		destination.ApiProperties = nil
	}

	// BackupPolicy
	if account.BackupPolicy != nil {
		var backupPolicy storage.BackupPolicy_STATUS
		err := account.BackupPolicy.AssignProperties_To_BackupPolicy_STATUS(&backupPolicy)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_BackupPolicy_STATUS() to populate field BackupPolicy")
		}
		destination.BackupPolicy = &backupPolicy
	} else {
		destination.BackupPolicy = nil
	}

	// Capabilities
	if account.Capabilities != nil {
		capabilityList := make([]storage.Capability_STATUS, len(account.Capabilities))
		for capabilityIndex, capabilityItem := range account.Capabilities {
			// Shadow the loop variable to avoid aliasing
			capabilityItem := capabilityItem
			var capability storage.Capability_STATUS
			err := capabilityItem.AssignProperties_To_Capability_STATUS(&capability)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_Capability_STATUS() to populate field Capabilities")
			}
			capabilityList[capabilityIndex] = capability
		}
		destination.Capabilities = capabilityList
	} else {
		destination.Capabilities = nil
	}

	// Capacity
	if propertyBag.Contains("Capacity") {
		var capacity storage.Capacity_STATUS
		err := propertyBag.Pull("Capacity", &capacity)
		if err != nil {
			return eris.Wrap(err, "pulling 'Capacity' from propertyBag")
		}

		destination.Capacity = &capacity
	} else {
		destination.Capacity = nil
	}

	// Conditions
	destination.Conditions = genruntime.CloneSliceOfCondition(account.Conditions)

	// ConnectorOffer
	destination.ConnectorOffer = genruntime.ClonePointerToString(account.ConnectorOffer)

	// ConsistencyPolicy
	if account.ConsistencyPolicy != nil {
		var consistencyPolicy storage.ConsistencyPolicy_STATUS
		err := account.ConsistencyPolicy.AssignProperties_To_ConsistencyPolicy_STATUS(&consistencyPolicy)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_ConsistencyPolicy_STATUS() to populate field ConsistencyPolicy")
		}
		destination.ConsistencyPolicy = &consistencyPolicy
	} else {
		destination.ConsistencyPolicy = nil
	}

	// Cors
	if account.Cors != nil {
		corList := make([]storage.CorsPolicy_STATUS, len(account.Cors))
		for corIndex, corItem := range account.Cors {
			// Shadow the loop variable to avoid aliasing
			corItem := corItem
			var cor storage.CorsPolicy_STATUS
			err := corItem.AssignProperties_To_CorsPolicy_STATUS(&cor)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_CorsPolicy_STATUS() to populate field Cors")
			}
			corList[corIndex] = cor
		}
		destination.Cors = corList
	} else {
		destination.Cors = nil
	}

	// CreateMode
	if propertyBag.Contains("CreateMode") {
		var createMode string
		err := propertyBag.Pull("CreateMode", &createMode)
		if err != nil {
			return eris.Wrap(err, "pulling 'CreateMode' from propertyBag")
		}

		destination.CreateMode = &createMode
	} else {
		destination.CreateMode = nil
	}

	// CustomerManagedKeyStatus
	if propertyBag.Contains("CustomerManagedKeyStatus") {
		var customerManagedKeyStatus string
		err := propertyBag.Pull("CustomerManagedKeyStatus", &customerManagedKeyStatus)
		if err != nil {
			return eris.Wrap(err, "pulling 'CustomerManagedKeyStatus' from propertyBag")
		}

		destination.CustomerManagedKeyStatus = &customerManagedKeyStatus
	} else {
		destination.CustomerManagedKeyStatus = nil
	}

	// DatabaseAccountOfferType
	destination.DatabaseAccountOfferType = genruntime.ClonePointerToString(account.DatabaseAccountOfferType)

	// DefaultIdentity
	destination.DefaultIdentity = genruntime.ClonePointerToString(account.DefaultIdentity)

	// DisableKeyBasedMetadataWriteAccess
	if account.DisableKeyBasedMetadataWriteAccess != nil {
		disableKeyBasedMetadataWriteAccess := *account.DisableKeyBasedMetadataWriteAccess
		destination.DisableKeyBasedMetadataWriteAccess = &disableKeyBasedMetadataWriteAccess
	} else {
		destination.DisableKeyBasedMetadataWriteAccess = nil
	}

	// DisableLocalAuth
	if propertyBag.Contains("DisableLocalAuth") {
		var disableLocalAuth bool
		err := propertyBag.Pull("DisableLocalAuth", &disableLocalAuth)
		if err != nil {
			return eris.Wrap(err, "pulling 'DisableLocalAuth' from propertyBag")
		}

		destination.DisableLocalAuth = &disableLocalAuth
	} else {
		destination.DisableLocalAuth = nil
	}

	// DocumentEndpoint
	destination.DocumentEndpoint = genruntime.ClonePointerToString(account.DocumentEndpoint)

	// EnableAnalyticalStorage
	if account.EnableAnalyticalStorage != nil {
		enableAnalyticalStorage := *account.EnableAnalyticalStorage
		destination.EnableAnalyticalStorage = &enableAnalyticalStorage
	} else {
		destination.EnableAnalyticalStorage = nil
	}

	// EnableAutomaticFailover
	if account.EnableAutomaticFailover != nil {
		enableAutomaticFailover := *account.EnableAutomaticFailover
		destination.EnableAutomaticFailover = &enableAutomaticFailover
	} else {
		destination.EnableAutomaticFailover = nil
	}

	// EnableBurstCapacity
	if propertyBag.Contains("EnableBurstCapacity") {
		var enableBurstCapacity bool
		err := propertyBag.Pull("EnableBurstCapacity", &enableBurstCapacity)
		if err != nil {
			return eris.Wrap(err, "pulling 'EnableBurstCapacity' from propertyBag")
		}

		destination.EnableBurstCapacity = &enableBurstCapacity
	} else {
		destination.EnableBurstCapacity = nil
	}

	// EnableCassandraConnector
	if account.EnableCassandraConnector != nil {
		enableCassandraConnector := *account.EnableCassandraConnector
		destination.EnableCassandraConnector = &enableCassandraConnector
	} else {
		destination.EnableCassandraConnector = nil
	}

	// EnableFreeTier
	if account.EnableFreeTier != nil {
		enableFreeTier := *account.EnableFreeTier
		destination.EnableFreeTier = &enableFreeTier
	} else {
		destination.EnableFreeTier = nil
	}

	// EnableMultipleWriteLocations
	if account.EnableMultipleWriteLocations != nil {
		enableMultipleWriteLocation := *account.EnableMultipleWriteLocations
		destination.EnableMultipleWriteLocations = &enableMultipleWriteLocation
	} else {
		destination.EnableMultipleWriteLocations = nil
	}

	// EnablePartitionMerge
	if propertyBag.Contains("EnablePartitionMerge") {
		var enablePartitionMerge bool
		err := propertyBag.Pull("EnablePartitionMerge", &enablePartitionMerge)
		if err != nil {
			return eris.Wrap(err, "pulling 'EnablePartitionMerge' from propertyBag")
		}

		destination.EnablePartitionMerge = &enablePartitionMerge
	} else {
		destination.EnablePartitionMerge = nil
	}

	// FailoverPolicies
	if account.FailoverPolicies != nil {
		failoverPolicyList := make([]storage.FailoverPolicy_STATUS, len(account.FailoverPolicies))
		for failoverPolicyIndex, failoverPolicyItem := range account.FailoverPolicies {
			// Shadow the loop variable to avoid aliasing
			failoverPolicyItem := failoverPolicyItem
			var failoverPolicy storage.FailoverPolicy_STATUS
			err := failoverPolicyItem.AssignProperties_To_FailoverPolicy_STATUS(&failoverPolicy)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_FailoverPolicy_STATUS() to populate field FailoverPolicies")
			}
			failoverPolicyList[failoverPolicyIndex] = failoverPolicy
		}
		destination.FailoverPolicies = failoverPolicyList
	} else {
		destination.FailoverPolicies = nil
	}

	// Id
	destination.Id = genruntime.ClonePointerToString(account.Id)

	// Identity
	if account.Identity != nil {
		var identity storage.ManagedServiceIdentity_STATUS
		err := account.Identity.AssignProperties_To_ManagedServiceIdentity_STATUS(&identity)
		if err != nil {
			return eris.Wrap(err, "calling AssignProperties_To_ManagedServiceIdentity_STATUS() to populate field Identity")
		}
		destination.Identity = &identity
	} else {
		destination.Identity = nil
	}

	// InstanceId
	if propertyBag.Contains("InstanceId") {
		var instanceId string
		err := propertyBag.Pull("InstanceId", &instanceId)
		if err != nil {
			return eris.Wrap(err, "pulling 'InstanceId' from propertyBag")
		}

		destination.InstanceId = &instanceId
	} else {
		destination.InstanceId = nil
	}

	// IpRules
	if account.IpRules != nil {
		ipRuleList := make([]storage.IpAddressOrRange_STATUS, len(account.IpRules))
		for ipRuleIndex, ipRuleItem := range account.IpRules {
			// Shadow the loop variable to avoid aliasing
			ipRuleItem := ipRuleItem
			var ipRule storage.IpAddressOrRange_STATUS
			err := ipRuleItem.AssignProperties_To_IpAddressOrRange_STATUS(&ipRule)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_IpAddressOrRange_STATUS() to populate field IpRules")
			}
			ipRuleList[ipRuleIndex] = ipRule
		}
		destination.IpRules = ipRuleList
	} else {
		destination.IpRules = nil
	}

	// IsVirtualNetworkFilterEnabled
	if account.IsVirtualNetworkFilterEnabled != nil {
		isVirtualNetworkFilterEnabled := *account.IsVirtualNetworkFilterEnabled
		destination.IsVirtualNetworkFilterEnabled = &isVirtualNetworkFilterEnabled
	} else {
		destination.IsVirtualNetworkFilterEnabled = nil
	}

	// KeyVaultKeyUri
	destination.KeyVaultKeyUri = genruntime.ClonePointerToString(account.KeyVaultKeyUri)

	// KeysMetadata
	if propertyBag.Contains("KeysMetadata") {
		var keysMetadatum storage.DatabaseAccountKeysMetadata_STATUS
		err := propertyBag.Pull("KeysMetadata", &keysMetadatum)
		if err != nil {
			return eris.Wrap(err, "pulling 'KeysMetadata' from propertyBag")
		}

		destination.KeysMetadata = &keysMetadatum
	} else {
		destination.KeysMetadata = nil
	}

	// Kind
	destination.Kind = genruntime.ClonePointerToString(account.Kind)

	// Location
	destination.Location = genruntime.ClonePointerToString(account.Location)

	// Locations
	if account.Locations != nil {
		locationList := make([]storage.Location_STATUS, len(account.Locations))
		for locationIndex, locationItem := range account.Locations {
			// Shadow the loop variable to avoid aliasing
			locationItem := locationItem
			var location storage.Location_STATUS
			err := locationItem.AssignProperties_To_Location_STATUS(&location)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field Locations")
			}
			locationList[locationIndex] = location
		}
		destination.Locations = locationList
	} else {
		destination.Locations = nil
	}

	// MinimalTlsVersion
	if propertyBag.Contains("MinimalTlsVersion") {
		var minimalTlsVersion string
		err := propertyBag.Pull("MinimalTlsVersion", &minimalTlsVersion)
		if err != nil {
			return eris.Wrap(err, "pulling 'MinimalTlsVersion' from propertyBag")
		}

		destination.MinimalTlsVersion = &minimalTlsVersion
	} else {
		destination.MinimalTlsVersion = nil
	}

	// Name
	destination.Name = genruntime.ClonePointerToString(account.Name)

	// NetworkAclBypass
	destination.NetworkAclBypass = genruntime.ClonePointerToString(account.NetworkAclBypass)

	// NetworkAclBypassResourceIds
	destination.NetworkAclBypassResourceIds = genruntime.CloneSliceOfString(account.NetworkAclBypassResourceIds)

	// PrivateEndpointConnections
	if account.PrivateEndpointConnections != nil {
		privateEndpointConnectionList := make([]storage.PrivateEndpointConnection_STATUS, len(account.PrivateEndpointConnections))
		for privateEndpointConnectionIndex, privateEndpointConnectionItem := range account.PrivateEndpointConnections {
			// Shadow the loop variable to avoid aliasing
			privateEndpointConnectionItem := privateEndpointConnectionItem
			var privateEndpointConnection storage.PrivateEndpointConnection_STATUS
			err := privateEndpointConnectionItem.AssignProperties_To_PrivateEndpointConnection_STATUS(&privateEndpointConnection)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_PrivateEndpointConnection_STATUS() to populate field PrivateEndpointConnections")
			}
			privateEndpointConnectionList[privateEndpointConnectionIndex] = privateEndpointConnection
		}
		destination.PrivateEndpointConnections = privateEndpointConnectionList
	} else {
		destination.PrivateEndpointConnections = nil
	}

	// ProvisioningState
	destination.ProvisioningState = genruntime.ClonePointerToString(account.ProvisioningState)

	// PublicNetworkAccess
	destination.PublicNetworkAccess = genruntime.ClonePointerToString(account.PublicNetworkAccess)

	// ReadLocations
	if account.ReadLocations != nil {
		readLocationList := make([]storage.Location_STATUS, len(account.ReadLocations))
		for readLocationIndex, readLocationItem := range account.ReadLocations {
			// Shadow the loop variable to avoid aliasing
			readLocationItem := readLocationItem
			var readLocation storage.Location_STATUS
			err := readLocationItem.AssignProperties_To_Location_STATUS(&readLocation)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field ReadLocations")
			}
			readLocationList[readLocationIndex] = readLocation
		}
		destination.ReadLocations = readLocationList
	} else {
		destination.ReadLocations = nil
	}

	// RestoreParameters
	if propertyBag.Contains("RestoreParameters") {
		var restoreParameter storage.RestoreParameters_STATUS
		err := propertyBag.Pull("RestoreParameters", &restoreParameter)
		if err != nil {
			return eris.Wrap(err, "pulling 'RestoreParameters' from propertyBag")
		}

		destination.RestoreParameters = &restoreParameter
	} else {
		destination.RestoreParameters = nil
	}

	// SystemData
	if propertyBag.Contains("SystemData") {
		var systemDatum storage.SystemData_STATUS
		err := propertyBag.Pull("SystemData", &systemDatum)
		if err != nil {
			return eris.Wrap(err, "pulling 'SystemData' from propertyBag")
		}

		destination.SystemData = &systemDatum
	} else {
		destination.SystemData = nil
	}

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

	// Type
	destination.Type = genruntime.ClonePointerToString(account.Type)

	// VirtualNetworkRules
	if account.VirtualNetworkRules != nil {
		virtualNetworkRuleList := make([]storage.VirtualNetworkRule_STATUS, len(account.VirtualNetworkRules))
		for virtualNetworkRuleIndex, virtualNetworkRuleItem := range account.VirtualNetworkRules {
			// Shadow the loop variable to avoid aliasing
			virtualNetworkRuleItem := virtualNetworkRuleItem
			var virtualNetworkRule storage.VirtualNetworkRule_STATUS
			err := virtualNetworkRuleItem.AssignProperties_To_VirtualNetworkRule_STATUS(&virtualNetworkRule)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_VirtualNetworkRule_STATUS() to populate field VirtualNetworkRules")
			}
			virtualNetworkRuleList[virtualNetworkRuleIndex] = virtualNetworkRule
		}
		destination.VirtualNetworkRules = virtualNetworkRuleList
	} else {
		destination.VirtualNetworkRules = nil
	}

	// WriteLocations
	if account.WriteLocations != nil {
		writeLocationList := make([]storage.Location_STATUS, len(account.WriteLocations))
		for writeLocationIndex, writeLocationItem := range account.WriteLocations {
			// Shadow the loop variable to avoid aliasing
			writeLocationItem := writeLocationItem
			var writeLocation storage.Location_STATUS
			err := writeLocationItem.AssignProperties_To_Location_STATUS(&writeLocation)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field WriteLocations")
			}
			writeLocationList[writeLocationIndex] = writeLocation
		}
		destination.WriteLocations = writeLocationList
	} else {
		destination.WriteLocations = nil
	}

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

	// Invoke the augmentConversionForDatabaseAccount_STATUS interface (if implemented) to customize the conversion
	var accountAsAny any = account
	if augmentedAccount, ok := accountAsAny.(augmentConversionForDatabaseAccount_STATUS); ok {
		err := augmentedAccount.AssignPropertiesTo(destination)
		if err != nil {
			return eris.Wrap(err, "calling augmented AssignPropertiesTo() for conversion")
		}
	}

	// No error
	return nil
}