func()

in v2/api/documentdb/v1api20210515/storage/database_account_types_gen.go [735:1140]
305 lines of code
58 McCabe index (conditional complexity)

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

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

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

	// AzureName
	destination.AzureName = account.AzureName

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

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

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

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

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

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

	// Cors
	if account.Cors != nil {
		corList := make([]storage.CorsPolicy, len(account.Cors))
		for corIndex, corItem := range account.Cors {
			// Shadow the loop variable to avoid aliasing
			corItem := corItem
			var cor storage.CorsPolicy
			err := corItem.AssignProperties_To_CorsPolicy(&cor)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_CorsPolicy() 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
	}

	// 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
	}

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

	// IpRules
	if account.IpRules != nil {
		ipRuleList := make([]storage.IpAddressOrRange, len(account.IpRules))
		for ipRuleIndex, ipRuleItem := range account.IpRules {
			// Shadow the loop variable to avoid aliasing
			ipRuleItem := ipRuleItem
			var ipRule storage.IpAddressOrRange
			err := ipRuleItem.AssignProperties_To_IpAddressOrRange(&ipRule)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_IpAddressOrRange() 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)

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

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

	// Locations
	if account.Locations != nil {
		locationList := make([]storage.Location, len(account.Locations))
		for locationIndex, locationItem := range account.Locations {
			// Shadow the loop variable to avoid aliasing
			locationItem := locationItem
			var location storage.Location
			err := locationItem.AssignProperties_To_Location(&location)
			if err != nil {
				return eris.Wrap(err, "calling AssignProperties_To_Location() 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
	}

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

	// NetworkAclBypassResourceIds
	if len(account.NetworkAclBypassResourceIds) > 0 {
		propertyBag.Add("NetworkAclBypassResourceIds", account.NetworkAclBypassResourceIds)
	} else {
		propertyBag.Remove("NetworkAclBypassResourceIds")
	}

	// NetworkAclBypassResourceReferences
	if propertyBag.Contains("NetworkAclBypassResourceReferences") {
		var networkAclBypassResourceReference []genruntime.ResourceReference
		err := propertyBag.Pull("NetworkAclBypassResourceReferences", &networkAclBypassResourceReference)
		if err != nil {
			return eris.Wrap(err, "pulling 'NetworkAclBypassResourceReferences' from propertyBag")
		}

		destination.NetworkAclBypassResourceReferences = networkAclBypassResourceReference
	} else {
		destination.NetworkAclBypassResourceReferences = nil
	}

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

	// OriginalVersion
	destination.OriginalVersion = account.OriginalVersion

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

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

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

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

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

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

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

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

	// No error
	return nil
}