gateway.pb.setters.fm.go

// Code generated by protoc-gen-fieldmask. DO NOT EDIT.

package ttnpb

import fmt "fmt"

func (dst *GatewayBrand) SetFields(src *GatewayBrand, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "id":
			if len(subs) > 0 {
				return fmt.Errorf("'id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Id = src.Id
			} else {
				var zero string
				dst.Id = zero
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "url":
			if len(subs) > 0 {
				return fmt.Errorf("'url' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Url = src.Url
			} else {
				var zero string
				dst.Url = zero
			}
		case "logos":
			if len(subs) > 0 {
				return fmt.Errorf("'logos' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Logos = src.Logos
			} else {
				dst.Logos = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayModel) SetFields(src *GatewayModel, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "id":
			if len(subs) > 0 {
				return fmt.Errorf("'id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Id = src.Id
			} else {
				var zero string
				dst.Id = zero
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayVersionIdentifiers) SetFields(src *GatewayVersionIdentifiers, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "model_id":
			if len(subs) > 0 {
				return fmt.Errorf("'model_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ModelId = src.ModelId
			} else {
				var zero string
				dst.ModelId = zero
			}
		case "hardware_version":
			if len(subs) > 0 {
				return fmt.Errorf("'hardware_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.HardwareVersion = src.HardwareVersion
			} else {
				var zero string
				dst.HardwareVersion = zero
			}
		case "firmware_version":
			if len(subs) > 0 {
				return fmt.Errorf("'firmware_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FirmwareVersion = src.FirmwareVersion
			} else {
				var zero string
				dst.FirmwareVersion = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayRadio) SetFields(src *GatewayRadio, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "enable":
			if len(subs) > 0 {
				return fmt.Errorf("'enable' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Enable = src.Enable
			} else {
				var zero bool
				dst.Enable = zero
			}
		case "chip_type":
			if len(subs) > 0 {
				return fmt.Errorf("'chip_type' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ChipType = src.ChipType
			} else {
				var zero string
				dst.ChipType = zero
			}
		case "frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Frequency = src.Frequency
			} else {
				var zero uint64
				dst.Frequency = zero
			}
		case "rssi_offset":
			if len(subs) > 0 {
				return fmt.Errorf("'rssi_offset' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RssiOffset = src.RssiOffset
			} else {
				var zero float32
				dst.RssiOffset = zero
			}
		case "tx_configuration":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayRadio_TxConfiguration
				if (src == nil || src.TxConfiguration == nil) && dst.TxConfiguration == nil {
					continue
				}
				if src != nil {
					newSrc = src.TxConfiguration
				}
				if dst.TxConfiguration != nil {
					newDst = dst.TxConfiguration
				} else {
					newDst = &GatewayRadio_TxConfiguration{}
					dst.TxConfiguration = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.TxConfiguration = src.TxConfiguration
				} else {
					dst.TxConfiguration = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayClaimAuthenticationCode) SetFields(src *GatewayClaimAuthenticationCode, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "secret":
			if len(subs) > 0 {
				var newDst, newSrc *Secret
				if (src == nil || src.Secret == nil) && dst.Secret == nil {
					continue
				}
				if src != nil {
					newSrc = src.Secret
				}
				if dst.Secret != nil {
					newDst = dst.Secret
				} else {
					newDst = &Secret{}
					dst.Secret = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Secret = src.Secret
				} else {
					dst.Secret = nil
				}
			}
		case "valid_from":
			if len(subs) > 0 {
				return fmt.Errorf("'valid_from' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ValidFrom = src.ValidFrom
			} else {
				dst.ValidFrom = nil
			}
		case "valid_to":
			if len(subs) > 0 {
				return fmt.Errorf("'valid_to' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ValidTo = src.ValidTo
			} else {
				dst.ValidTo = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *Gateway) SetFields(src *Gateway, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.Ids == nil) && dst.Ids == nil {
					continue
				}
				if src != nil {
					newSrc = src.Ids
				}
				if dst.Ids != nil {
					newDst = dst.Ids
				} else {
					newDst = &GatewayIdentifiers{}
					dst.Ids = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Ids = src.Ids
				} else {
					dst.Ids = nil
				}
			}
		case "created_at":
			if len(subs) > 0 {
				return fmt.Errorf("'created_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CreatedAt = src.CreatedAt
			} else {
				dst.CreatedAt = nil
			}
		case "updated_at":
			if len(subs) > 0 {
				return fmt.Errorf("'updated_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UpdatedAt = src.UpdatedAt
			} else {
				dst.UpdatedAt = nil
			}
		case "deleted_at":
			if len(subs) > 0 {
				return fmt.Errorf("'deleted_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DeletedAt = src.DeletedAt
			} else {
				dst.DeletedAt = nil
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "description":
			if len(subs) > 0 {
				return fmt.Errorf("'description' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Description = src.Description
			} else {
				var zero string
				dst.Description = zero
			}
		case "attributes":
			if len(subs) > 0 {
				return fmt.Errorf("'attributes' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Attributes = src.Attributes
			} else {
				dst.Attributes = nil
			}
		case "contact_info":
			if len(subs) > 0 {
				return fmt.Errorf("'contact_info' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ContactInfo = src.ContactInfo
			} else {
				dst.ContactInfo = nil
			}
		case "administrative_contact":
			if len(subs) > 0 {
				var newDst, newSrc *OrganizationOrUserIdentifiers
				if (src == nil || src.AdministrativeContact == nil) && dst.AdministrativeContact == nil {
					continue
				}
				if src != nil {
					newSrc = src.AdministrativeContact
				}
				if dst.AdministrativeContact != nil {
					newDst = dst.AdministrativeContact
				} else {
					newDst = &OrganizationOrUserIdentifiers{}
					dst.AdministrativeContact = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.AdministrativeContact = src.AdministrativeContact
				} else {
					dst.AdministrativeContact = nil
				}
			}
		case "technical_contact":
			if len(subs) > 0 {
				var newDst, newSrc *OrganizationOrUserIdentifiers
				if (src == nil || src.TechnicalContact == nil) && dst.TechnicalContact == nil {
					continue
				}
				if src != nil {
					newSrc = src.TechnicalContact
				}
				if dst.TechnicalContact != nil {
					newDst = dst.TechnicalContact
				} else {
					newDst = &OrganizationOrUserIdentifiers{}
					dst.TechnicalContact = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.TechnicalContact = src.TechnicalContact
				} else {
					dst.TechnicalContact = nil
				}
			}
		case "version_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayVersionIdentifiers
				if (src == nil || src.VersionIds == nil) && dst.VersionIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.VersionIds
				}
				if dst.VersionIds != nil {
					newDst = dst.VersionIds
				} else {
					newDst = &GatewayVersionIdentifiers{}
					dst.VersionIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.VersionIds = src.VersionIds
				} else {
					dst.VersionIds = nil
				}
			}
		case "gateway_server_address":
			if len(subs) > 0 {
				return fmt.Errorf("'gateway_server_address' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.GatewayServerAddress = src.GatewayServerAddress
			} else {
				var zero string
				dst.GatewayServerAddress = zero
			}
		case "auto_update":
			if len(subs) > 0 {
				return fmt.Errorf("'auto_update' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AutoUpdate = src.AutoUpdate
			} else {
				var zero bool
				dst.AutoUpdate = zero
			}
		case "update_channel":
			if len(subs) > 0 {
				return fmt.Errorf("'update_channel' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UpdateChannel = src.UpdateChannel
			} else {
				var zero string
				dst.UpdateChannel = zero
			}
		case "frequency_plan_id":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency_plan_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrequencyPlanId = src.FrequencyPlanId
			} else {
				var zero string
				dst.FrequencyPlanId = zero
			}
		case "frequency_plan_ids":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency_plan_ids' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrequencyPlanIds = src.FrequencyPlanIds
			} else {
				dst.FrequencyPlanIds = nil
			}
		case "antennas":
			if len(subs) > 0 {
				return fmt.Errorf("'antennas' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Antennas = src.Antennas
			} else {
				dst.Antennas = nil
			}
		case "status_public":
			if len(subs) > 0 {
				return fmt.Errorf("'status_public' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.StatusPublic = src.StatusPublic
			} else {
				var zero bool
				dst.StatusPublic = zero
			}
		case "location_public":
			if len(subs) > 0 {
				return fmt.Errorf("'location_public' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LocationPublic = src.LocationPublic
			} else {
				var zero bool
				dst.LocationPublic = zero
			}
		case "schedule_downlink_late":
			if len(subs) > 0 {
				return fmt.Errorf("'schedule_downlink_late' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ScheduleDownlinkLate = src.ScheduleDownlinkLate
			} else {
				var zero bool
				dst.ScheduleDownlinkLate = zero
			}
		case "enforce_duty_cycle":
			if len(subs) > 0 {
				return fmt.Errorf("'enforce_duty_cycle' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.EnforceDutyCycle = src.EnforceDutyCycle
			} else {
				var zero bool
				dst.EnforceDutyCycle = zero
			}
		case "downlink_path_constraint":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_path_constraint' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkPathConstraint = src.DownlinkPathConstraint
			} else {
				dst.DownlinkPathConstraint = 0
			}
		case "schedule_anytime_delay":
			if len(subs) > 0 {
				return fmt.Errorf("'schedule_anytime_delay' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ScheduleAnytimeDelay = src.ScheduleAnytimeDelay
			} else {
				dst.ScheduleAnytimeDelay = nil
			}
		case "update_location_from_status":
			if len(subs) > 0 {
				return fmt.Errorf("'update_location_from_status' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UpdateLocationFromStatus = src.UpdateLocationFromStatus
			} else {
				var zero bool
				dst.UpdateLocationFromStatus = zero
			}
		case "lbs_lns_secret":
			if len(subs) > 0 {
				var newDst, newSrc *Secret
				if (src == nil || src.LbsLnsSecret == nil) && dst.LbsLnsSecret == nil {
					continue
				}
				if src != nil {
					newSrc = src.LbsLnsSecret
				}
				if dst.LbsLnsSecret != nil {
					newDst = dst.LbsLnsSecret
				} else {
					newDst = &Secret{}
					dst.LbsLnsSecret = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.LbsLnsSecret = src.LbsLnsSecret
				} else {
					dst.LbsLnsSecret = nil
				}
			}
		case "claim_authentication_code":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayClaimAuthenticationCode
				if (src == nil || src.ClaimAuthenticationCode == nil) && dst.ClaimAuthenticationCode == nil {
					continue
				}
				if src != nil {
					newSrc = src.ClaimAuthenticationCode
				}
				if dst.ClaimAuthenticationCode != nil {
					newDst = dst.ClaimAuthenticationCode
				} else {
					newDst = &GatewayClaimAuthenticationCode{}
					dst.ClaimAuthenticationCode = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ClaimAuthenticationCode = src.ClaimAuthenticationCode
				} else {
					dst.ClaimAuthenticationCode = nil
				}
			}
		case "target_cups_uri":
			if len(subs) > 0 {
				return fmt.Errorf("'target_cups_uri' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.TargetCupsUri = src.TargetCupsUri
			} else {
				var zero string
				dst.TargetCupsUri = zero
			}
		case "target_cups_key":
			if len(subs) > 0 {
				var newDst, newSrc *Secret
				if (src == nil || src.TargetCupsKey == nil) && dst.TargetCupsKey == nil {
					continue
				}
				if src != nil {
					newSrc = src.TargetCupsKey
				}
				if dst.TargetCupsKey != nil {
					newDst = dst.TargetCupsKey
				} else {
					newDst = &Secret{}
					dst.TargetCupsKey = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.TargetCupsKey = src.TargetCupsKey
				} else {
					dst.TargetCupsKey = nil
				}
			}
		case "require_authenticated_connection":
			if len(subs) > 0 {
				return fmt.Errorf("'require_authenticated_connection' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RequireAuthenticatedConnection = src.RequireAuthenticatedConnection
			} else {
				var zero bool
				dst.RequireAuthenticatedConnection = zero
			}
		case "lrfhss":
			if len(subs) > 0 {
				var newDst, newSrc *Gateway_LRFHSS
				if (src == nil || src.Lrfhss == nil) && dst.Lrfhss == nil {
					continue
				}
				if src != nil {
					newSrc = src.Lrfhss
				}
				if dst.Lrfhss != nil {
					newDst = dst.Lrfhss
				} else {
					newDst = &Gateway_LRFHSS{}
					dst.Lrfhss = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Lrfhss = src.Lrfhss
				} else {
					dst.Lrfhss = nil
				}
			}
		case "disable_packet_broker_forwarding":
			if len(subs) > 0 {
				return fmt.Errorf("'disable_packet_broker_forwarding' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DisablePacketBrokerForwarding = src.DisablePacketBrokerForwarding
			} else {
				var zero bool
				dst.DisablePacketBrokerForwarding = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *Gateways) SetFields(src *Gateways, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateways":
			if len(subs) > 0 {
				return fmt.Errorf("'gateways' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Gateways = src.Gateways
			} else {
				dst.Gateways = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetGatewayRequest) SetFields(src *GetGatewayRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetGatewayIdentifiersForEUIRequest) SetFields(src *GetGatewayIdentifiersForEUIRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "eui":
			if len(subs) > 0 {
				return fmt.Errorf("'eui' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Eui = src.Eui
			} else {
				dst.Eui = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListGatewaysRequest) SetFields(src *ListGatewaysRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "collaborator":
			if len(subs) > 0 {
				var newDst, newSrc *OrganizationOrUserIdentifiers
				if (src == nil || src.Collaborator == nil) && dst.Collaborator == nil {
					continue
				}
				if src != nil {
					newSrc = src.Collaborator
				}
				if dst.Collaborator != nil {
					newDst = dst.Collaborator
				} else {
					newDst = &OrganizationOrUserIdentifiers{}
					dst.Collaborator = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Collaborator = src.Collaborator
				} else {
					dst.Collaborator = nil
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}
		case "order":
			if len(subs) > 0 {
				return fmt.Errorf("'order' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Order = src.Order
			} else {
				var zero string
				dst.Order = zero
			}
		case "limit":
			if len(subs) > 0 {
				return fmt.Errorf("'limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Limit = src.Limit
			} else {
				var zero uint32
				dst.Limit = zero
			}
		case "page":
			if len(subs) > 0 {
				return fmt.Errorf("'page' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Page = src.Page
			} else {
				var zero uint32
				dst.Page = zero
			}
		case "deleted":
			if len(subs) > 0 {
				return fmt.Errorf("'deleted' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Deleted = src.Deleted
			} else {
				var zero bool
				dst.Deleted = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *CreateGatewayRequest) SetFields(src *CreateGatewayRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway":
			if len(subs) > 0 {
				var newDst, newSrc *Gateway
				if (src == nil || src.Gateway == nil) && dst.Gateway == nil {
					continue
				}
				if src != nil {
					newSrc = src.Gateway
				}
				if dst.Gateway != nil {
					newDst = dst.Gateway
				} else {
					newDst = &Gateway{}
					dst.Gateway = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Gateway = src.Gateway
				} else {
					dst.Gateway = nil
				}
			}
		case "collaborator":
			if len(subs) > 0 {
				var newDst, newSrc *OrganizationOrUserIdentifiers
				if (src == nil || src.Collaborator == nil) && dst.Collaborator == nil {
					continue
				}
				if src != nil {
					newSrc = src.Collaborator
				}
				if dst.Collaborator != nil {
					newDst = dst.Collaborator
				} else {
					newDst = &OrganizationOrUserIdentifiers{}
					dst.Collaborator = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Collaborator = src.Collaborator
				} else {
					dst.Collaborator = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *UpdateGatewayRequest) SetFields(src *UpdateGatewayRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway":
			if len(subs) > 0 {
				var newDst, newSrc *Gateway
				if (src == nil || src.Gateway == nil) && dst.Gateway == nil {
					continue
				}
				if src != nil {
					newSrc = src.Gateway
				}
				if dst.Gateway != nil {
					newDst = dst.Gateway
				} else {
					newDst = &Gateway{}
					dst.Gateway = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Gateway = src.Gateway
				} else {
					dst.Gateway = nil
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListGatewayAPIKeysRequest) SetFields(src *ListGatewayAPIKeysRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "order":
			if len(subs) > 0 {
				return fmt.Errorf("'order' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Order = src.Order
			} else {
				var zero string
				dst.Order = zero
			}
		case "limit":
			if len(subs) > 0 {
				return fmt.Errorf("'limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Limit = src.Limit
			} else {
				var zero uint32
				dst.Limit = zero
			}
		case "page":
			if len(subs) > 0 {
				return fmt.Errorf("'page' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Page = src.Page
			} else {
				var zero uint32
				dst.Page = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetGatewayAPIKeyRequest) SetFields(src *GetGatewayAPIKeyRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "key_id":
			if len(subs) > 0 {
				return fmt.Errorf("'key_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.KeyId = src.KeyId
			} else {
				var zero string
				dst.KeyId = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *CreateGatewayAPIKeyRequest) SetFields(src *CreateGatewayAPIKeyRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "rights":
			if len(subs) > 0 {
				return fmt.Errorf("'rights' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rights = src.Rights
			} else {
				dst.Rights = nil
			}
		case "expires_at":
			if len(subs) > 0 {
				return fmt.Errorf("'expires_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ExpiresAt = src.ExpiresAt
			} else {
				dst.ExpiresAt = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *UpdateGatewayAPIKeyRequest) SetFields(src *UpdateGatewayAPIKeyRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "api_key":
			if len(subs) > 0 {
				var newDst, newSrc *APIKey
				if (src == nil || src.ApiKey == nil) && dst.ApiKey == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApiKey
				}
				if dst.ApiKey != nil {
					newDst = dst.ApiKey
				} else {
					newDst = &APIKey{}
					dst.ApiKey = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApiKey = src.ApiKey
				} else {
					dst.ApiKey = nil
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListGatewayCollaboratorsRequest) SetFields(src *ListGatewayCollaboratorsRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "limit":
			if len(subs) > 0 {
				return fmt.Errorf("'limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Limit = src.Limit
			} else {
				var zero uint32
				dst.Limit = zero
			}
		case "page":
			if len(subs) > 0 {
				return fmt.Errorf("'page' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Page = src.Page
			} else {
				var zero uint32
				dst.Page = zero
			}
		case "order":
			if len(subs) > 0 {
				return fmt.Errorf("'order' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Order = src.Order
			} else {
				var zero string
				dst.Order = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetGatewayCollaboratorRequest) SetFields(src *GetGatewayCollaboratorRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "collaborator":
			if len(subs) > 0 {
				var newDst, newSrc *OrganizationOrUserIdentifiers
				if (src == nil || src.Collaborator == nil) && dst.Collaborator == nil {
					continue
				}
				if src != nil {
					newSrc = src.Collaborator
				}
				if dst.Collaborator != nil {
					newDst = dst.Collaborator
				} else {
					newDst = &OrganizationOrUserIdentifiers{}
					dst.Collaborator = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Collaborator = src.Collaborator
				} else {
					dst.Collaborator = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *SetGatewayCollaboratorRequest) SetFields(src *SetGatewayCollaboratorRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "collaborator":
			if len(subs) > 0 {
				var newDst, newSrc *Collaborator
				if (src == nil || src.Collaborator == nil) && dst.Collaborator == nil {
					continue
				}
				if src != nil {
					newSrc = src.Collaborator
				}
				if dst.Collaborator != nil {
					newDst = dst.Collaborator
				} else {
					newDst = &Collaborator{}
					dst.Collaborator = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Collaborator = src.Collaborator
				} else {
					dst.Collaborator = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayAntenna) SetFields(src *GatewayAntenna, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gain":
			if len(subs) > 0 {
				return fmt.Errorf("'gain' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Gain = src.Gain
			} else {
				var zero float32
				dst.Gain = zero
			}
		case "location":
			if len(subs) > 0 {
				var newDst, newSrc *Location
				if (src == nil || src.Location == nil) && dst.Location == nil {
					continue
				}
				if src != nil {
					newSrc = src.Location
				}
				if dst.Location != nil {
					newDst = dst.Location
				} else {
					newDst = &Location{}
					dst.Location = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Location = src.Location
				} else {
					dst.Location = nil
				}
			}
		case "attributes":
			if len(subs) > 0 {
				return fmt.Errorf("'attributes' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Attributes = src.Attributes
			} else {
				dst.Attributes = nil
			}
		case "placement":
			if len(subs) > 0 {
				return fmt.Errorf("'placement' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Placement = src.Placement
			} else {
				dst.Placement = 0
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayStatus) SetFields(src *GatewayStatus, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "time":
			if len(subs) > 0 {
				return fmt.Errorf("'time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Time = src.Time
			} else {
				dst.Time = nil
			}
		case "boot_time":
			if len(subs) > 0 {
				return fmt.Errorf("'boot_time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BootTime = src.BootTime
			} else {
				dst.BootTime = nil
			}
		case "versions":
			if len(subs) > 0 {
				return fmt.Errorf("'versions' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Versions = src.Versions
			} else {
				dst.Versions = nil
			}
		case "antenna_locations":
			if len(subs) > 0 {
				return fmt.Errorf("'antenna_locations' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AntennaLocations = src.AntennaLocations
			} else {
				dst.AntennaLocations = nil
			}
		case "ip":
			if len(subs) > 0 {
				return fmt.Errorf("'ip' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Ip = src.Ip
			} else {
				dst.Ip = nil
			}
		case "metrics":
			if len(subs) > 0 {
				return fmt.Errorf("'metrics' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Metrics = src.Metrics
			} else {
				dst.Metrics = nil
			}
		case "advanced":
			if len(subs) > 0 {
				return fmt.Errorf("'advanced' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Advanced = src.Advanced
			} else {
				dst.Advanced = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayRemoteAddress) SetFields(src *GatewayRemoteAddress, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ip":
			if len(subs) > 0 {
				return fmt.Errorf("'ip' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Ip = src.Ip
			} else {
				var zero string
				dst.Ip = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayConnectionStats) SetFields(src *GatewayConnectionStats, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "connected_at":
			if len(subs) > 0 {
				return fmt.Errorf("'connected_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ConnectedAt = src.ConnectedAt
			} else {
				dst.ConnectedAt = nil
			}
		case "disconnected_at":
			if len(subs) > 0 {
				return fmt.Errorf("'disconnected_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DisconnectedAt = src.DisconnectedAt
			} else {
				dst.DisconnectedAt = nil
			}
		case "protocol":
			if len(subs) > 0 {
				return fmt.Errorf("'protocol' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Protocol = src.Protocol
			} else {
				var zero string
				dst.Protocol = zero
			}
		case "last_status_received_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_status_received_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastStatusReceivedAt = src.LastStatusReceivedAt
			} else {
				dst.LastStatusReceivedAt = nil
			}
		case "last_status":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayStatus
				if (src == nil || src.LastStatus == nil) && dst.LastStatus == nil {
					continue
				}
				if src != nil {
					newSrc = src.LastStatus
				}
				if dst.LastStatus != nil {
					newDst = dst.LastStatus
				} else {
					newDst = &GatewayStatus{}
					dst.LastStatus = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.LastStatus = src.LastStatus
				} else {
					dst.LastStatus = nil
				}
			}
		case "last_uplink_received_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_uplink_received_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastUplinkReceivedAt = src.LastUplinkReceivedAt
			} else {
				dst.LastUplinkReceivedAt = nil
			}
		case "uplink_count":
			if len(subs) > 0 {
				return fmt.Errorf("'uplink_count' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UplinkCount = src.UplinkCount
			} else {
				var zero uint64
				dst.UplinkCount = zero
			}
		case "last_downlink_received_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_downlink_received_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastDownlinkReceivedAt = src.LastDownlinkReceivedAt
			} else {
				dst.LastDownlinkReceivedAt = nil
			}
		case "downlink_count":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_count' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkCount = src.DownlinkCount
			} else {
				var zero uint64
				dst.DownlinkCount = zero
			}
		case "round_trip_times":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayConnectionStats_RoundTripTimes
				if (src == nil || src.RoundTripTimes == nil) && dst.RoundTripTimes == nil {
					continue
				}
				if src != nil {
					newSrc = src.RoundTripTimes
				}
				if dst.RoundTripTimes != nil {
					newDst = dst.RoundTripTimes
				} else {
					newDst = &GatewayConnectionStats_RoundTripTimes{}
					dst.RoundTripTimes = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.RoundTripTimes = src.RoundTripTimes
				} else {
					dst.RoundTripTimes = nil
				}
			}
		case "sub_bands":
			if len(subs) > 0 {
				return fmt.Errorf("'sub_bands' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SubBands = src.SubBands
			} else {
				dst.SubBands = nil
			}
		case "gateway_remote_address":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayRemoteAddress
				if (src == nil || src.GatewayRemoteAddress == nil) && dst.GatewayRemoteAddress == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayRemoteAddress
				}
				if dst.GatewayRemoteAddress != nil {
					newDst = dst.GatewayRemoteAddress
				} else {
					newDst = &GatewayRemoteAddress{}
					dst.GatewayRemoteAddress = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayRemoteAddress = src.GatewayRemoteAddress
				} else {
					dst.GatewayRemoteAddress = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayRadio_TxConfiguration) SetFields(src *GatewayRadio_TxConfiguration, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "min_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'min_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinFrequency = src.MinFrequency
			} else {
				var zero uint64
				dst.MinFrequency = zero
			}
		case "max_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'max_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxFrequency = src.MaxFrequency
			} else {
				var zero uint64
				dst.MaxFrequency = zero
			}
		case "notch_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'notch_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NotchFrequency = src.NotchFrequency
			} else {
				var zero uint64
				dst.NotchFrequency = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *Gateway_LRFHSS) SetFields(src *Gateway_LRFHSS, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "supported":
			if len(subs) > 0 {
				return fmt.Errorf("'supported' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Supported = src.Supported
			} else {
				var zero bool
				dst.Supported = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayConnectionStats_RoundTripTimes) SetFields(src *GatewayConnectionStats_RoundTripTimes, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "min":
			if len(subs) > 0 {
				return fmt.Errorf("'min' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Min = src.Min
			} else {
				dst.Min = nil
			}
		case "max":
			if len(subs) > 0 {
				return fmt.Errorf("'max' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Max = src.Max
			} else {
				dst.Max = nil
			}
		case "median":
			if len(subs) > 0 {
				return fmt.Errorf("'median' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Median = src.Median
			} else {
				dst.Median = nil
			}
		case "count":
			if len(subs) > 0 {
				return fmt.Errorf("'count' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Count = src.Count
			} else {
				var zero uint32
				dst.Count = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GatewayConnectionStats_SubBand) SetFields(src *GatewayConnectionStats_SubBand, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "min_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'min_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinFrequency = src.MinFrequency
			} else {
				var zero uint64
				dst.MinFrequency = zero
			}
		case "max_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'max_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxFrequency = src.MaxFrequency
			} else {
				var zero uint64
				dst.MaxFrequency = zero
			}
		case "downlink_utilization_limit":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_utilization_limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkUtilizationLimit = src.DownlinkUtilizationLimit
			} else {
				var zero float32
				dst.DownlinkUtilizationLimit = zero
			}
		case "downlink_utilization":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_utilization' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkUtilization = src.DownlinkUtilization
			} else {
				var zero float32
				dst.DownlinkUtilization = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}