probe.pb.object_ext.go

// Code generated by protoc-gen-goten-object
// File: watchdog/proto/v1alpha2/probe.proto
// DO NOT EDIT!!!

package probe

import (
	"fmt"
	"sort"

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
)

// proto imports
import (
	ntt_memo "github.com/cloudwan/edgelq-sdk/common/types/memo"
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	devices_device "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/device"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/service_account"
	common "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/common"
	probe_group "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probe_group"
	project "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/project"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
)

// ensure the imports are used
var (
	_ = new(fmt.Stringer)
	_ = new(sort.Interface)

	_ = new(proto.Message)
	_ = fieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &ntt_memo.Memo{}
	_ = &ntt_meta.Meta{}
	_ = &devices_device.Device{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &timestamp.Timestamp{}
	_ = &common.SoftwareVersion{}
	_ = &probe_group.ProbeGroup{}
	_ = &project.Project{}
)

func (o *Probe) GotenObjectExt() {}

func (o *Probe) MakeFullFieldMask() *Probe_FieldMask {
	return FullProbe_FieldMask()
}

func (o *Probe) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_FieldMask()
}

func (o *Probe) MakeDiffFieldMask(other *Probe) *Probe_FieldMask {
	if o == nil && other == nil {
		return &Probe_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_FieldMask()
	}

	res := &Probe_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorName})
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorDisplayName})
	}
	if o.GetLowerDisplayName() != other.GetLowerDisplayName() {
		res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorLowerDisplayName})
	}
	{
		subMask := o.GetMetadata().MakeDiffFieldMask(other.GetMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Probe_FieldSubPath{selector: Probe_FieldPathSelectorMetadata, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetSpec().MakeDiffFieldMask(other.GetSpec())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorSpec})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Probe_FieldSubPath{selector: Probe_FieldPathSelectorSpec, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetStatus().MakeDiffFieldMask(other.GetStatus())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorStatus})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Probe_FieldSubPath{selector: Probe_FieldPathSelectorStatus, subPath: subpath})
			}
		}
	}

	if len(o.GetMemo()) == len(other.GetMemo()) {
		for i, lValue := range o.GetMemo() {
			rValue := other.GetMemo()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorMemo})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Probe_FieldTerminalPath{selector: Probe_FieldPathSelectorMemo})
	}
	return res
}

func (o *Probe) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe))
}

func (o *Probe) Clone() *Probe {
	if o == nil {
		return nil
	}
	result := &Probe{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &Name{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.DisplayName = o.DisplayName
	result.LowerDisplayName = o.LowerDisplayName
	result.Metadata = o.Metadata.Clone()
	result.Spec = o.Spec.Clone()
	result.Status = o.Status.Clone()
	result.Memo = make([]*ntt_memo.Memo, len(o.Memo))
	for i, sourceValue := range o.Memo {
		result.Memo[i] = sourceValue.Clone()
	}
	return result
}

func (o *Probe) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe) Merge(source *Probe) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &Name{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	o.DisplayName = source.GetDisplayName()
	o.LowerDisplayName = source.GetLowerDisplayName()
	if source.GetMetadata() != nil {
		if o.Metadata == nil {
			o.Metadata = new(ntt_meta.Meta)
		}
		o.Metadata.Merge(source.GetMetadata())
	}
	if source.GetSpec() != nil {
		if o.Spec == nil {
			o.Spec = new(Probe_Spec)
		}
		o.Spec.Merge(source.GetSpec())
	}
	if source.GetStatus() != nil {
		if o.Status == nil {
			o.Status = new(Probe_Status)
		}
		o.Status.Merge(source.GetStatus())
	}
	for _, sourceValue := range source.GetMemo() {
		exists := false
		for _, currentValue := range o.Memo {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *ntt_memo.Memo
			if sourceValue != nil {
				newDstElement = new(ntt_memo.Memo)
				newDstElement.Merge(sourceValue)
			}
			o.Memo = append(o.Memo, newDstElement)
		}
	}

}

func (o *Probe) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe))
}

func (o *Probe_Spec) GotenObjectExt() {}

func (o *Probe_Spec) MakeFullFieldMask() *Probe_Spec_FieldMask {
	return FullProbe_Spec_FieldMask()
}

func (o *Probe_Spec) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_FieldMask()
}

func (o *Probe_Spec) MakeDiffFieldMask(other *Probe_Spec) *Probe_Spec_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_FieldMask()
	}

	res := &Probe_Spec_FieldMask{}
	if o.GetProbeGroup().String() != other.GetProbeGroup().String() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorProbeGroup})
	}
	if o.GetProbeGroupName() != other.GetProbeGroupName() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorProbeGroupName})
	}
	if o.GetDevice().String() != other.GetDevice().String() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorDevice})
	}
	if o.GetEnabled() != other.GetEnabled() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorEnabled})
	}
	{
		subMask := o.GetPrimaryLocation().MakeDiffFieldMask(other.GetPrimaryLocation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorPrimaryLocation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorPrimaryLocation, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetLocationDiscovery().MakeDiffFieldMask(other.GetLocationDiscovery())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorLocationDiscovery})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorLocationDiscovery, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetContactInfo().MakeDiffFieldMask(other.GetContactInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorContactInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorContactInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetActivation().MakeDiffFieldMask(other.GetActivation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorActivation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorActivation, subPath: subpath})
			}
		}
	}
	if o.GetDisableSpeedtest() != other.GetDisableSpeedtest() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorDisableSpeedtest})
	}
	{
		subMask := o.GetAccessToken().MakeDiffFieldMask(other.GetAccessToken())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorAccessToken})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorAccessToken, subPath: subpath})
			}
		}
	}
	if o.GetAgentType() != other.GetAgentType() {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorAgentType})
	}

	if len(o.GetExternalIpCheckUrl()) == len(other.GetExternalIpCheckUrl()) {
		for i, lValue := range o.GetExternalIpCheckUrl() {
			rValue := other.GetExternalIpCheckUrl()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorExternalIpCheckUrl})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorExternalIpCheckUrl})
	}
	{
		subMask := o.GetTargetServers().MakeDiffFieldMask(other.GetTargetServers())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorTargetServers})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorTargetServers, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetPcapSettings().MakeDiffFieldMask(other.GetPcapSettings())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpec_FieldTerminalPath{selector: ProbeSpec_FieldPathSelectorPcapSettings})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpec_FieldSubPath{selector: ProbeSpec_FieldPathSelectorPcapSettings, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Probe_Spec) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec))
}

func (o *Probe_Spec) Clone() *Probe_Spec {
	if o == nil {
		return nil
	}
	result := &Probe_Spec{}
	if o.ProbeGroup == nil {
		result.ProbeGroup = nil
	} else if data, err := o.ProbeGroup.ProtoString(); err != nil {
		panic(err)
	} else {
		result.ProbeGroup = &probe_group.Reference{}
		if err := result.ProbeGroup.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.ProbeGroupName = o.ProbeGroupName
	if o.Device == nil {
		result.Device = nil
	} else if data, err := o.Device.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Device = &devices_device.Reference{}
		if err := result.Device.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.Enabled = o.Enabled
	result.PrimaryLocation = o.PrimaryLocation.Clone()
	result.LocationDiscovery = o.LocationDiscovery.Clone()
	result.ContactInfo = o.ContactInfo.Clone()
	result.Activation = o.Activation.Clone()
	result.DisableSpeedtest = o.DisableSpeedtest
	result.AccessToken = o.AccessToken.Clone()
	result.AgentType = o.AgentType
	result.ExternalIpCheckUrl = make([]string, len(o.ExternalIpCheckUrl))
	for i, sourceValue := range o.ExternalIpCheckUrl {
		result.ExternalIpCheckUrl[i] = sourceValue
	}
	result.TargetServers = o.TargetServers.Clone()
	result.PcapSettings = o.PcapSettings.Clone()
	return result
}

func (o *Probe_Spec) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec) Merge(source *Probe_Spec) {
	if source.GetProbeGroup() != nil {
		if data, err := source.GetProbeGroup().ProtoString(); err != nil {
			panic(err)
		} else {
			o.ProbeGroup = &probe_group.Reference{}
			if err := o.ProbeGroup.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.ProbeGroup = nil
	}
	o.ProbeGroupName = source.GetProbeGroupName()
	if source.GetDevice() != nil {
		if data, err := source.GetDevice().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Device = &devices_device.Reference{}
			if err := o.Device.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Device = nil
	}
	o.Enabled = source.GetEnabled()
	if source.GetPrimaryLocation() != nil {
		if o.PrimaryLocation == nil {
			o.PrimaryLocation = new(common.Location)
		}
		o.PrimaryLocation.Merge(source.GetPrimaryLocation())
	}
	if source.GetLocationDiscovery() != nil {
		if o.LocationDiscovery == nil {
			o.LocationDiscovery = new(common.LocationDiscoverySpec)
		}
		o.LocationDiscovery.Merge(source.GetLocationDiscovery())
	}
	if source.GetContactInfo() != nil {
		if o.ContactInfo == nil {
			o.ContactInfo = new(common.ContactInformation)
		}
		o.ContactInfo.Merge(source.GetContactInfo())
	}
	if source.GetActivation() != nil {
		if o.Activation == nil {
			o.Activation = new(Probe_Spec_ActivationSpec)
		}
		o.Activation.Merge(source.GetActivation())
	}
	o.DisableSpeedtest = source.GetDisableSpeedtest()
	if source.GetAccessToken() != nil {
		if o.AccessToken == nil {
			o.AccessToken = new(Probe_Spec_AccessTokenSpec)
		}
		o.AccessToken.Merge(source.GetAccessToken())
	}
	o.AgentType = source.GetAgentType()
	for _, sourceValue := range source.GetExternalIpCheckUrl() {
		exists := false
		for _, currentValue := range o.ExternalIpCheckUrl {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ExternalIpCheckUrl = append(o.ExternalIpCheckUrl, newDstElement)
		}
	}

	if source.GetTargetServers() != nil {
		if o.TargetServers == nil {
			o.TargetServers = new(Probe_Spec_TargetServers)
		}
		o.TargetServers.Merge(source.GetTargetServers())
	}
	if source.GetPcapSettings() != nil {
		if o.PcapSettings == nil {
			o.PcapSettings = new(Probe_Spec_PcapSettings)
		}
		o.PcapSettings.Merge(source.GetPcapSettings())
	}
}

func (o *Probe_Spec) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec))
}

func (o *Probe_Status) GotenObjectExt() {}

func (o *Probe_Status) MakeFullFieldMask() *Probe_Status_FieldMask {
	return FullProbe_Status_FieldMask()
}

func (o *Probe_Status) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_FieldMask()
}

func (o *Probe_Status) MakeDiffFieldMask(other *Probe_Status) *Probe_Status_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_FieldMask()
	}

	res := &Probe_Status_FieldMask{}
	if o.GetExternalIpAddressV4() != other.GetExternalIpAddressV4() {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorExternalIpAddressV4})
	}
	if o.GetExternalIpAddressV6() != other.GetExternalIpAddressV6() {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorExternalIpAddressV6})
	}
	if o.GetExternalHostname() != other.GetExternalHostname() {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorExternalHostname})
	}
	{
		subMask := o.GetAsInfo().MakeDiffFieldMask(other.GetAsInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorAsInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorAsInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetCarrier().MakeDiffFieldMask(other.GetCarrier())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorCarrier})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorCarrier, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetActiveLocation().MakeDiffFieldMask(other.GetActiveLocation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorActiveLocation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorActiveLocation, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetDiscoveredLocation().MakeDiffFieldMask(other.GetDiscoveredLocation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorDiscoveredLocation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorDiscoveredLocation, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetSoftwareVersion().MakeDiffFieldMask(other.GetSoftwareVersion())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorSoftwareVersion})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorSoftwareVersion, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetSystemInfo().MakeDiffFieldMask(other.GetSystemInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorSystemInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorSystemInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetActivation().MakeDiffFieldMask(other.GetActivation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorActivation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorActivation, subPath: subpath})
			}
		}
	}
	if o.GetConnection() != other.GetConnection() {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorConnection})
	}
	if !proto.Equal(o.GetConnectionStatusChangeTime(), other.GetConnectionStatusChangeTime()) {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorConnectionStatusChangeTime})
	}
	{
		subMask := o.GetBandwidth().MakeDiffFieldMask(other.GetBandwidth())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorBandwidth})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorBandwidth, subPath: subpath})
			}
		}
	}

	if len(o.GetNetworkInterfaces()) == len(other.GetNetworkInterfaces()) {
		for i, lValue := range o.GetNetworkInterfaces() {
			rValue := other.GetNetworkInterfaces()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorNetworkInterfaces})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorNetworkInterfaces})
	}
	if o.GetAgentType() != other.GetAgentType() {
		res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorAgentType})
	}
	{
		subMask := o.GetProxyConfig().MakeDiffFieldMask(other.GetProxyConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatus_FieldTerminalPath{selector: ProbeStatus_FieldPathSelectorProxyConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatus_FieldSubPath{selector: ProbeStatus_FieldPathSelectorProxyConfig, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Probe_Status) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status))
}

func (o *Probe_Status) Clone() *Probe_Status {
	if o == nil {
		return nil
	}
	result := &Probe_Status{}
	result.ExternalIpAddressV4 = o.ExternalIpAddressV4
	result.ExternalIpAddressV6 = o.ExternalIpAddressV6
	result.ExternalHostname = o.ExternalHostname
	result.AsInfo = o.AsInfo.Clone()
	result.Carrier = o.Carrier.Clone()
	result.ActiveLocation = o.ActiveLocation.Clone()
	result.DiscoveredLocation = o.DiscoveredLocation.Clone()
	result.SoftwareVersion = o.SoftwareVersion.Clone()
	result.SystemInfo = o.SystemInfo.Clone()
	result.Activation = o.Activation.Clone()
	result.Connection = o.Connection
	result.ConnectionStatusChangeTime = proto.Clone(o.ConnectionStatusChangeTime).(*timestamp.Timestamp)
	result.Bandwidth = o.Bandwidth.Clone()
	result.NetworkInterfaces = map[string]*Probe_Status_NetworkInterface{}
	for key, sourceValue := range o.NetworkInterfaces {
		result.NetworkInterfaces[key] = sourceValue.Clone()
	}
	result.AgentType = o.AgentType
	result.ProxyConfig = o.ProxyConfig.Clone()
	return result
}

func (o *Probe_Status) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status) Merge(source *Probe_Status) {
	o.ExternalIpAddressV4 = source.GetExternalIpAddressV4()
	o.ExternalIpAddressV6 = source.GetExternalIpAddressV6()
	o.ExternalHostname = source.GetExternalHostname()
	if source.GetAsInfo() != nil {
		if o.AsInfo == nil {
			o.AsInfo = new(common.ASInfo)
		}
		o.AsInfo.Merge(source.GetAsInfo())
	}
	if source.GetCarrier() != nil {
		if o.Carrier == nil {
			o.Carrier = new(common.Carrier)
		}
		o.Carrier.Merge(source.GetCarrier())
	}
	if source.GetActiveLocation() != nil {
		if o.ActiveLocation == nil {
			o.ActiveLocation = new(common.Location)
		}
		o.ActiveLocation.Merge(source.GetActiveLocation())
	}
	if source.GetDiscoveredLocation() != nil {
		if o.DiscoveredLocation == nil {
			o.DiscoveredLocation = new(common.Location)
		}
		o.DiscoveredLocation.Merge(source.GetDiscoveredLocation())
	}
	if source.GetSoftwareVersion() != nil {
		if o.SoftwareVersion == nil {
			o.SoftwareVersion = new(common.SoftwareVersion)
		}
		o.SoftwareVersion.Merge(source.GetSoftwareVersion())
	}
	if source.GetSystemInfo() != nil {
		if o.SystemInfo == nil {
			o.SystemInfo = new(Probe_Status_System)
		}
		o.SystemInfo.Merge(source.GetSystemInfo())
	}
	if source.GetActivation() != nil {
		if o.Activation == nil {
			o.Activation = new(Probe_Status_ActivationState)
		}
		o.Activation.Merge(source.GetActivation())
	}
	o.Connection = source.GetConnection()
	if source.GetConnectionStatusChangeTime() != nil {
		if o.ConnectionStatusChangeTime == nil {
			o.ConnectionStatusChangeTime = new(timestamp.Timestamp)
		}
		proto.Merge(o.ConnectionStatusChangeTime, source.GetConnectionStatusChangeTime())
	}
	if source.GetBandwidth() != nil {
		if o.Bandwidth == nil {
			o.Bandwidth = new(Probe_Status_Bandwidth)
		}
		o.Bandwidth.Merge(source.GetBandwidth())
	}
	if source.GetNetworkInterfaces() != nil {
		if o.NetworkInterfaces == nil {
			o.NetworkInterfaces = make(map[string]*Probe_Status_NetworkInterface, len(source.GetNetworkInterfaces()))
		}
		for key, sourceValue := range source.GetNetworkInterfaces() {
			if sourceValue != nil {
				if o.NetworkInterfaces[key] == nil {
					o.NetworkInterfaces[key] = new(Probe_Status_NetworkInterface)
				}
				o.NetworkInterfaces[key].Merge(sourceValue)
			}
		}
	}
	o.AgentType = source.GetAgentType()
	if source.GetProxyConfig() != nil {
		if o.ProxyConfig == nil {
			o.ProxyConfig = new(Probe_Status_ProxyConfig)
		}
		o.ProxyConfig.Merge(source.GetProxyConfig())
	}
}

func (o *Probe_Status) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status))
}

func (o *Probe_Spec_ActivationSpec) GotenObjectExt() {}

func (o *Probe_Spec_ActivationSpec) MakeFullFieldMask() *Probe_Spec_ActivationSpec_FieldMask {
	return FullProbe_Spec_ActivationSpec_FieldMask()
}

func (o *Probe_Spec_ActivationSpec) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_ActivationSpec_FieldMask()
}

func (o *Probe_Spec_ActivationSpec) MakeDiffFieldMask(other *Probe_Spec_ActivationSpec) *Probe_Spec_ActivationSpec_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_ActivationSpec_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_ActivationSpec_FieldMask()
	}

	res := &Probe_Spec_ActivationSpec_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorType})
	}
	if o.GetToken() != other.GetToken() {
		res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorToken})
	}
	if o.GetSendInvitationOnCreate() != other.GetSendInvitationOnCreate() {
		res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorSendInvitationOnCreate})
	}

	if len(o.GetInvitationExtras()) == len(other.GetInvitationExtras()) {
		for i, lValue := range o.GetInvitationExtras() {
			rValue := other.GetInvitationExtras()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorInvitationExtras})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorInvitationExtras})
	}
	if o.GetReusableToken() != other.GetReusableToken() {
		res.Paths = append(res.Paths, &ProbeSpecActivationSpec_FieldTerminalPath{selector: ProbeSpecActivationSpec_FieldPathSelectorReusableToken})
	}
	return res
}

func (o *Probe_Spec_ActivationSpec) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_ActivationSpec))
}

func (o *Probe_Spec_ActivationSpec) Clone() *Probe_Spec_ActivationSpec {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_ActivationSpec{}
	result.Type = o.Type
	result.Token = o.Token
	result.SendInvitationOnCreate = o.SendInvitationOnCreate
	result.InvitationExtras = map[string]string{}
	for key, sourceValue := range o.InvitationExtras {
		result.InvitationExtras[key] = sourceValue
	}
	result.ReusableToken = o.ReusableToken
	return result
}

func (o *Probe_Spec_ActivationSpec) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_ActivationSpec) Merge(source *Probe_Spec_ActivationSpec) {
	o.Type = source.GetType()
	o.Token = source.GetToken()
	o.SendInvitationOnCreate = source.GetSendInvitationOnCreate()
	if source.GetInvitationExtras() != nil {
		if o.InvitationExtras == nil {
			o.InvitationExtras = make(map[string]string, len(source.GetInvitationExtras()))
		}
		for key, sourceValue := range source.GetInvitationExtras() {
			o.InvitationExtras[key] = sourceValue
		}
	}
	o.ReusableToken = source.GetReusableToken()
}

func (o *Probe_Spec_ActivationSpec) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_ActivationSpec))
}

func (o *Probe_Spec_AccessTokenSpec) GotenObjectExt() {}

func (o *Probe_Spec_AccessTokenSpec) MakeFullFieldMask() *Probe_Spec_AccessTokenSpec_FieldMask {
	return FullProbe_Spec_AccessTokenSpec_FieldMask()
}

func (o *Probe_Spec_AccessTokenSpec) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_AccessTokenSpec_FieldMask()
}

func (o *Probe_Spec_AccessTokenSpec) MakeDiffFieldMask(other *Probe_Spec_AccessTokenSpec) *Probe_Spec_AccessTokenSpec_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_AccessTokenSpec_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_AccessTokenSpec_FieldMask()
	}

	res := &Probe_Spec_AccessTokenSpec_FieldMask{}
	if o.GetEnable() != other.GetEnable() {
		res.Paths = append(res.Paths, &ProbeSpecAccessTokenSpec_FieldTerminalPath{selector: ProbeSpecAccessTokenSpec_FieldPathSelectorEnable})
	}
	if o.GetAccessToken() != other.GetAccessToken() {
		res.Paths = append(res.Paths, &ProbeSpecAccessTokenSpec_FieldTerminalPath{selector: ProbeSpecAccessTokenSpec_FieldPathSelectorAccessToken})
	}
	return res
}

func (o *Probe_Spec_AccessTokenSpec) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_AccessTokenSpec))
}

func (o *Probe_Spec_AccessTokenSpec) Clone() *Probe_Spec_AccessTokenSpec {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_AccessTokenSpec{}
	result.Enable = o.Enable
	result.AccessToken = o.AccessToken
	return result
}

func (o *Probe_Spec_AccessTokenSpec) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_AccessTokenSpec) Merge(source *Probe_Spec_AccessTokenSpec) {
	o.Enable = source.GetEnable()
	o.AccessToken = source.GetAccessToken()
}

func (o *Probe_Spec_AccessTokenSpec) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_AccessTokenSpec))
}

func (o *Probe_Spec_TargetServers) GotenObjectExt() {}

func (o *Probe_Spec_TargetServers) MakeFullFieldMask() *Probe_Spec_TargetServers_FieldMask {
	return FullProbe_Spec_TargetServers_FieldMask()
}

func (o *Probe_Spec_TargetServers) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_TargetServers_FieldMask()
}

func (o *Probe_Spec_TargetServers) MakeDiffFieldMask(other *Probe_Spec_TargetServers) *Probe_Spec_TargetServers_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_TargetServers_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_TargetServers_FieldMask()
	}

	res := &Probe_Spec_TargetServers_FieldMask{}
	{
		subMask := o.GetIcmpTarget().MakeDiffFieldMask(other.GetIcmpTarget())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldTerminalPath{selector: ProbeSpecTargetServers_FieldPathSelectorIcmpTarget})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldSubPath{selector: ProbeSpecTargetServers_FieldPathSelectorIcmpTarget, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetUdpTarget().MakeDiffFieldMask(other.GetUdpTarget())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldTerminalPath{selector: ProbeSpecTargetServers_FieldPathSelectorUdpTarget})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldSubPath{selector: ProbeSpecTargetServers_FieldPathSelectorUdpTarget, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetSpeedTestTarget().MakeDiffFieldMask(other.GetSpeedTestTarget())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldTerminalPath{selector: ProbeSpecTargetServers_FieldPathSelectorSpeedTestTarget})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldSubPath{selector: ProbeSpecTargetServers_FieldPathSelectorSpeedTestTarget, subPath: subpath})
			}
		}
	}
	if o.GetTargetAddressType() != other.GetTargetAddressType() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldTerminalPath{selector: ProbeSpecTargetServers_FieldPathSelectorTargetAddressType})
	}
	if o.GetTargetIpVersion() != other.GetTargetIpVersion() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServers_FieldTerminalPath{selector: ProbeSpecTargetServers_FieldPathSelectorTargetIpVersion})
	}
	return res
}

func (o *Probe_Spec_TargetServers) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_TargetServers))
}

func (o *Probe_Spec_TargetServers) Clone() *Probe_Spec_TargetServers {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_TargetServers{}
	result.IcmpTarget = o.IcmpTarget.Clone()
	result.UdpTarget = o.UdpTarget.Clone()
	result.SpeedTestTarget = o.SpeedTestTarget.Clone()
	result.TargetAddressType = o.TargetAddressType
	result.TargetIpVersion = o.TargetIpVersion
	return result
}

func (o *Probe_Spec_TargetServers) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_TargetServers) Merge(source *Probe_Spec_TargetServers) {
	if source.GetIcmpTarget() != nil {
		if o.IcmpTarget == nil {
			o.IcmpTarget = new(Probe_Spec_TargetServers_IcmpTarget)
		}
		o.IcmpTarget.Merge(source.GetIcmpTarget())
	}
	if source.GetUdpTarget() != nil {
		if o.UdpTarget == nil {
			o.UdpTarget = new(Probe_Spec_TargetServers_UdpTarget)
		}
		o.UdpTarget.Merge(source.GetUdpTarget())
	}
	if source.GetSpeedTestTarget() != nil {
		if o.SpeedTestTarget == nil {
			o.SpeedTestTarget = new(Probe_Spec_TargetServers_SpeedTestTarget)
		}
		o.SpeedTestTarget.Merge(source.GetSpeedTestTarget())
	}
	o.TargetAddressType = source.GetTargetAddressType()
	o.TargetIpVersion = source.GetTargetIpVersion()
}

func (o *Probe_Spec_TargetServers) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_TargetServers))
}

func (o *Probe_Spec_PcapSettings) GotenObjectExt() {}

func (o *Probe_Spec_PcapSettings) MakeFullFieldMask() *Probe_Spec_PcapSettings_FieldMask {
	return FullProbe_Spec_PcapSettings_FieldMask()
}

func (o *Probe_Spec_PcapSettings) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_PcapSettings_FieldMask()
}

func (o *Probe_Spec_PcapSettings) MakeDiffFieldMask(other *Probe_Spec_PcapSettings) *Probe_Spec_PcapSettings_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_PcapSettings_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_PcapSettings_FieldMask()
	}

	res := &Probe_Spec_PcapSettings_FieldMask{}
	if o.GetEnable() != other.GetEnable() {
		res.Paths = append(res.Paths, &ProbeSpecPcapSettings_FieldTerminalPath{selector: ProbeSpecPcapSettings_FieldPathSelectorEnable})
	}
	if o.GetCaptureFullPacket() != other.GetCaptureFullPacket() {
		res.Paths = append(res.Paths, &ProbeSpecPcapSettings_FieldTerminalPath{selector: ProbeSpecPcapSettings_FieldPathSelectorCaptureFullPacket})
	}
	if o.GetOnDemandMode() != other.GetOnDemandMode() {
		res.Paths = append(res.Paths, &ProbeSpecPcapSettings_FieldTerminalPath{selector: ProbeSpecPcapSettings_FieldPathSelectorOnDemandMode})
	}
	if !proto.Equal(o.GetStopOnDemandModeBy(), other.GetStopOnDemandModeBy()) {
		res.Paths = append(res.Paths, &ProbeSpecPcapSettings_FieldTerminalPath{selector: ProbeSpecPcapSettings_FieldPathSelectorStopOnDemandModeBy})
	}
	return res
}

func (o *Probe_Spec_PcapSettings) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_PcapSettings))
}

func (o *Probe_Spec_PcapSettings) Clone() *Probe_Spec_PcapSettings {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_PcapSettings{}
	result.Enable = o.Enable
	result.CaptureFullPacket = o.CaptureFullPacket
	result.OnDemandMode = o.OnDemandMode
	result.StopOnDemandModeBy = proto.Clone(o.StopOnDemandModeBy).(*timestamp.Timestamp)
	return result
}

func (o *Probe_Spec_PcapSettings) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_PcapSettings) Merge(source *Probe_Spec_PcapSettings) {
	o.Enable = source.GetEnable()
	o.CaptureFullPacket = source.GetCaptureFullPacket()
	o.OnDemandMode = source.GetOnDemandMode()
	if source.GetStopOnDemandModeBy() != nil {
		if o.StopOnDemandModeBy == nil {
			o.StopOnDemandModeBy = new(timestamp.Timestamp)
		}
		proto.Merge(o.StopOnDemandModeBy, source.GetStopOnDemandModeBy())
	}
}

func (o *Probe_Spec_PcapSettings) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_PcapSettings))
}

func (o *Probe_Spec_TargetServers_IcmpTarget) GotenObjectExt() {}

func (o *Probe_Spec_TargetServers_IcmpTarget) MakeFullFieldMask() *Probe_Spec_TargetServers_IcmpTarget_FieldMask {
	return FullProbe_Spec_TargetServers_IcmpTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_IcmpTarget) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_TargetServers_IcmpTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_IcmpTarget) MakeDiffFieldMask(other *Probe_Spec_TargetServers_IcmpTarget) *Probe_Spec_TargetServers_IcmpTarget_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_TargetServers_IcmpTarget_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_TargetServers_IcmpTarget_FieldMask()
	}

	res := &Probe_Spec_TargetServers_IcmpTarget_FieldMask{}
	if o.GetEnabled() != other.GetEnabled() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServersIcmpTarget_FieldTerminalPath{selector: ProbeSpecTargetServersIcmpTarget_FieldPathSelectorEnabled})
	}
	return res
}

func (o *Probe_Spec_TargetServers_IcmpTarget) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_TargetServers_IcmpTarget))
}

func (o *Probe_Spec_TargetServers_IcmpTarget) Clone() *Probe_Spec_TargetServers_IcmpTarget {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_TargetServers_IcmpTarget{}
	result.Enabled = o.Enabled
	return result
}

func (o *Probe_Spec_TargetServers_IcmpTarget) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_TargetServers_IcmpTarget) Merge(source *Probe_Spec_TargetServers_IcmpTarget) {
	o.Enabled = source.GetEnabled()
}

func (o *Probe_Spec_TargetServers_IcmpTarget) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_TargetServers_IcmpTarget))
}

func (o *Probe_Spec_TargetServers_UdpTarget) GotenObjectExt() {}

func (o *Probe_Spec_TargetServers_UdpTarget) MakeFullFieldMask() *Probe_Spec_TargetServers_UdpTarget_FieldMask {
	return FullProbe_Spec_TargetServers_UdpTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_UdpTarget) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_TargetServers_UdpTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_UdpTarget) MakeDiffFieldMask(other *Probe_Spec_TargetServers_UdpTarget) *Probe_Spec_TargetServers_UdpTarget_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_TargetServers_UdpTarget_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_TargetServers_UdpTarget_FieldMask()
	}

	res := &Probe_Spec_TargetServers_UdpTarget_FieldMask{}
	if o.GetEnabled() != other.GetEnabled() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServersUdpTarget_FieldTerminalPath{selector: ProbeSpecTargetServersUdpTarget_FieldPathSelectorEnabled})
	}
	if o.GetPort() != other.GetPort() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServersUdpTarget_FieldTerminalPath{selector: ProbeSpecTargetServersUdpTarget_FieldPathSelectorPort})
	}
	return res
}

func (o *Probe_Spec_TargetServers_UdpTarget) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_TargetServers_UdpTarget))
}

func (o *Probe_Spec_TargetServers_UdpTarget) Clone() *Probe_Spec_TargetServers_UdpTarget {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_TargetServers_UdpTarget{}
	result.Enabled = o.Enabled
	result.Port = o.Port
	return result
}

func (o *Probe_Spec_TargetServers_UdpTarget) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_TargetServers_UdpTarget) Merge(source *Probe_Spec_TargetServers_UdpTarget) {
	o.Enabled = source.GetEnabled()
	o.Port = source.GetPort()
}

func (o *Probe_Spec_TargetServers_UdpTarget) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_TargetServers_UdpTarget))
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) GotenObjectExt() {}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) MakeFullFieldMask() *Probe_Spec_TargetServers_SpeedTestTarget_FieldMask {
	return FullProbe_Spec_TargetServers_SpeedTestTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Spec_TargetServers_SpeedTestTarget_FieldMask()
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) MakeDiffFieldMask(other *Probe_Spec_TargetServers_SpeedTestTarget) *Probe_Spec_TargetServers_SpeedTestTarget_FieldMask {
	if o == nil && other == nil {
		return &Probe_Spec_TargetServers_SpeedTestTarget_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Spec_TargetServers_SpeedTestTarget_FieldMask()
	}

	res := &Probe_Spec_TargetServers_SpeedTestTarget_FieldMask{}
	if o.GetEnabled() != other.GetEnabled() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServersSpeedTestTarget_FieldTerminalPath{selector: ProbeSpecTargetServersSpeedTestTarget_FieldPathSelectorEnabled})
	}
	if o.GetTcpPort() != other.GetTcpPort() {
		res.Paths = append(res.Paths, &ProbeSpecTargetServersSpeedTestTarget_FieldTerminalPath{selector: ProbeSpecTargetServersSpeedTestTarget_FieldPathSelectorTcpPort})
	}
	return res
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Spec_TargetServers_SpeedTestTarget))
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) Clone() *Probe_Spec_TargetServers_SpeedTestTarget {
	if o == nil {
		return nil
	}
	result := &Probe_Spec_TargetServers_SpeedTestTarget{}
	result.Enabled = o.Enabled
	result.TcpPort = o.TcpPort
	return result
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) Merge(source *Probe_Spec_TargetServers_SpeedTestTarget) {
	o.Enabled = source.GetEnabled()
	o.TcpPort = source.GetTcpPort()
}

func (o *Probe_Spec_TargetServers_SpeedTestTarget) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Spec_TargetServers_SpeedTestTarget))
}

func (o *Probe_Status_System) GotenObjectExt() {}

func (o *Probe_Status_System) MakeFullFieldMask() *Probe_Status_System_FieldMask {
	return FullProbe_Status_System_FieldMask()
}

func (o *Probe_Status_System) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_System_FieldMask()
}

func (o *Probe_Status_System) MakeDiffFieldMask(other *Probe_Status_System) *Probe_Status_System_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_System_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_System_FieldMask()
	}

	res := &Probe_Status_System_FieldMask{}
	if o.GetManufacturer() != other.GetManufacturer() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorManufacturer})
	}
	if o.GetModel() != other.GetModel() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorModel})
	}
	if o.GetSku() != other.GetSku() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorSku})
	}
	if o.GetFamily() != other.GetFamily() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorFamily})
	}
	if o.GetSerialNumber() != other.GetSerialNumber() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorSerialNumber})
	}
	if o.GetPlatform() != other.GetPlatform() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorPlatform})
	}
	if o.GetArchitecture() != other.GetArchitecture() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorArchitecture})
	}
	{
		subMask := o.GetOs().MakeDiffFieldMask(other.GetOs())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorOs})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatusSystem_FieldSubPath{selector: ProbeStatusSystem_FieldPathSelectorOs, subPath: subpath})
			}
		}
	}
	if o.GetHostName() != other.GetHostName() {
		res.Paths = append(res.Paths, &ProbeStatusSystem_FieldTerminalPath{selector: ProbeStatusSystem_FieldPathSelectorHostName})
	}
	return res
}

func (o *Probe_Status_System) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_System))
}

func (o *Probe_Status_System) Clone() *Probe_Status_System {
	if o == nil {
		return nil
	}
	result := &Probe_Status_System{}
	result.Manufacturer = o.Manufacturer
	result.Model = o.Model
	result.Sku = o.Sku
	result.Family = o.Family
	result.SerialNumber = o.SerialNumber
	result.Platform = o.Platform
	result.Architecture = o.Architecture
	result.Os = o.Os.Clone()
	result.HostName = o.HostName
	return result
}

func (o *Probe_Status_System) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_System) Merge(source *Probe_Status_System) {
	o.Manufacturer = source.GetManufacturer()
	o.Model = source.GetModel()
	o.Sku = source.GetSku()
	o.Family = source.GetFamily()
	o.SerialNumber = source.GetSerialNumber()
	o.Platform = source.GetPlatform()
	o.Architecture = source.GetArchitecture()
	if source.GetOs() != nil {
		if o.Os == nil {
			o.Os = new(Probe_Status_System_OS)
		}
		o.Os.Merge(source.GetOs())
	}
	o.HostName = source.GetHostName()
}

func (o *Probe_Status_System) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_System))
}

func (o *Probe_Status_ActivationState) GotenObjectExt() {}

func (o *Probe_Status_ActivationState) MakeFullFieldMask() *Probe_Status_ActivationState_FieldMask {
	return FullProbe_Status_ActivationState_FieldMask()
}

func (o *Probe_Status_ActivationState) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_ActivationState_FieldMask()
}

func (o *Probe_Status_ActivationState) MakeDiffFieldMask(other *Probe_Status_ActivationState) *Probe_Status_ActivationState_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_ActivationState_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_ActivationState_FieldMask()
	}

	res := &Probe_Status_ActivationState_FieldMask{}
	if o.GetStatus() != other.GetStatus() {
		res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldTerminalPath{selector: ProbeStatusActivationState_FieldPathSelectorStatus})
	}
	{
		subMask := o.GetCurrentSession().MakeDiffFieldMask(other.GetCurrentSession())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldTerminalPath{selector: ProbeStatusActivationState_FieldPathSelectorCurrentSession})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldSubPath{selector: ProbeStatusActivationState_FieldPathSelectorCurrentSession, subPath: subpath})
			}
		}
	}
	if o.GetServiceAccount().String() != other.GetServiceAccount().String() {
		res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldTerminalPath{selector: ProbeStatusActivationState_FieldPathSelectorServiceAccount})
	}
	{
		subMask := o.GetLastInvitation().MakeDiffFieldMask(other.GetLastInvitation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldTerminalPath{selector: ProbeStatusActivationState_FieldPathSelectorLastInvitation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ProbeStatusActivationState_FieldSubPath{selector: ProbeStatusActivationState_FieldPathSelectorLastInvitation, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Probe_Status_ActivationState) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_ActivationState))
}

func (o *Probe_Status_ActivationState) Clone() *Probe_Status_ActivationState {
	if o == nil {
		return nil
	}
	result := &Probe_Status_ActivationState{}
	result.Status = o.Status
	result.CurrentSession = o.CurrentSession.Clone()
	if o.ServiceAccount == nil {
		result.ServiceAccount = nil
	} else if data, err := o.ServiceAccount.ProtoString(); err != nil {
		panic(err)
	} else {
		result.ServiceAccount = &iam_service_account.Reference{}
		if err := result.ServiceAccount.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.LastInvitation = o.LastInvitation.Clone()
	return result
}

func (o *Probe_Status_ActivationState) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_ActivationState) Merge(source *Probe_Status_ActivationState) {
	o.Status = source.GetStatus()
	if source.GetCurrentSession() != nil {
		if o.CurrentSession == nil {
			o.CurrentSession = new(Probe_Status_ActivationState_Session)
		}
		o.CurrentSession.Merge(source.GetCurrentSession())
	}
	if source.GetServiceAccount() != nil {
		if data, err := source.GetServiceAccount().ProtoString(); err != nil {
			panic(err)
		} else {
			o.ServiceAccount = &iam_service_account.Reference{}
			if err := o.ServiceAccount.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.ServiceAccount = nil
	}
	if source.GetLastInvitation() != nil {
		if o.LastInvitation == nil {
			o.LastInvitation = new(Probe_Status_ActivationState_InvitationState)
		}
		o.LastInvitation.Merge(source.GetLastInvitation())
	}
}

func (o *Probe_Status_ActivationState) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_ActivationState))
}

func (o *Probe_Status_Bandwidth) GotenObjectExt() {}

func (o *Probe_Status_Bandwidth) MakeFullFieldMask() *Probe_Status_Bandwidth_FieldMask {
	return FullProbe_Status_Bandwidth_FieldMask()
}

func (o *Probe_Status_Bandwidth) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_Bandwidth_FieldMask()
}

func (o *Probe_Status_Bandwidth) MakeDiffFieldMask(other *Probe_Status_Bandwidth) *Probe_Status_Bandwidth_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_Bandwidth_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_Bandwidth_FieldMask()
	}

	res := &Probe_Status_Bandwidth_FieldMask{}
	if o.GetUploadMbps() != other.GetUploadMbps() {
		res.Paths = append(res.Paths, &ProbeStatusBandwidth_FieldTerminalPath{selector: ProbeStatusBandwidth_FieldPathSelectorUploadMbps})
	}
	if o.GetDownloadMbps() != other.GetDownloadMbps() {
		res.Paths = append(res.Paths, &ProbeStatusBandwidth_FieldTerminalPath{selector: ProbeStatusBandwidth_FieldPathSelectorDownloadMbps})
	}
	if o.GetTestServer() != other.GetTestServer() {
		res.Paths = append(res.Paths, &ProbeStatusBandwidth_FieldTerminalPath{selector: ProbeStatusBandwidth_FieldPathSelectorTestServer})
	}
	if o.GetServerIpAddress() != other.GetServerIpAddress() {
		res.Paths = append(res.Paths, &ProbeStatusBandwidth_FieldTerminalPath{selector: ProbeStatusBandwidth_FieldPathSelectorServerIpAddress})
	}
	if !proto.Equal(o.GetLastReported(), other.GetLastReported()) {
		res.Paths = append(res.Paths, &ProbeStatusBandwidth_FieldTerminalPath{selector: ProbeStatusBandwidth_FieldPathSelectorLastReported})
	}
	return res
}

func (o *Probe_Status_Bandwidth) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_Bandwidth))
}

func (o *Probe_Status_Bandwidth) Clone() *Probe_Status_Bandwidth {
	if o == nil {
		return nil
	}
	result := &Probe_Status_Bandwidth{}
	result.UploadMbps = o.UploadMbps
	result.DownloadMbps = o.DownloadMbps
	result.TestServer = o.TestServer
	result.ServerIpAddress = o.ServerIpAddress
	result.LastReported = proto.Clone(o.LastReported).(*timestamp.Timestamp)
	return result
}

func (o *Probe_Status_Bandwidth) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_Bandwidth) Merge(source *Probe_Status_Bandwidth) {
	o.UploadMbps = source.GetUploadMbps()
	o.DownloadMbps = source.GetDownloadMbps()
	o.TestServer = source.GetTestServer()
	o.ServerIpAddress = source.GetServerIpAddress()
	if source.GetLastReported() != nil {
		if o.LastReported == nil {
			o.LastReported = new(timestamp.Timestamp)
		}
		proto.Merge(o.LastReported, source.GetLastReported())
	}
}

func (o *Probe_Status_Bandwidth) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_Bandwidth))
}

func (o *Probe_Status_NetworkInterface) GotenObjectExt() {}

func (o *Probe_Status_NetworkInterface) MakeFullFieldMask() *Probe_Status_NetworkInterface_FieldMask {
	return FullProbe_Status_NetworkInterface_FieldMask()
}

func (o *Probe_Status_NetworkInterface) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_NetworkInterface_FieldMask()
}

func (o *Probe_Status_NetworkInterface) MakeDiffFieldMask(other *Probe_Status_NetworkInterface) *Probe_Status_NetworkInterface_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_NetworkInterface_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_NetworkInterface_FieldMask()
	}

	res := &Probe_Status_NetworkInterface_FieldMask{}
	if o.GetInterfaceName() != other.GetInterfaceName() {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorInterfaceName})
	}

	if len(o.GetIpAddressV4()) == len(other.GetIpAddressV4()) {
		for i, lValue := range o.GetIpAddressV4() {
			rValue := other.GetIpAddressV4()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorIpAddressV4})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorIpAddressV4})
	}

	if len(o.GetExternalIpAddressV4()) == len(other.GetExternalIpAddressV4()) {
		for i, lValue := range o.GetExternalIpAddressV4() {
			rValue := other.GetExternalIpAddressV4()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorExternalIpAddressV4})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorExternalIpAddressV4})
	}

	if len(o.GetIpAddressV6()) == len(other.GetIpAddressV6()) {
		for i, lValue := range o.GetIpAddressV6() {
			rValue := other.GetIpAddressV6()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorIpAddressV6})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorIpAddressV6})
	}

	if len(o.GetExternalIpAddressV6()) == len(other.GetExternalIpAddressV6()) {
		for i, lValue := range o.GetExternalIpAddressV6() {
			rValue := other.GetExternalIpAddressV6()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorExternalIpAddressV6})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorExternalIpAddressV6})
	}
	if o.GetHasV4DefaultRoute() != other.GetHasV4DefaultRoute() {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorHasV4DefaultRoute})
	}
	if o.GetHasV6DefaultRoute() != other.GetHasV6DefaultRoute() {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorHasV6DefaultRoute})
	}
	if o.GetHasBestV4DefaultRoute() != other.GetHasBestV4DefaultRoute() {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorHasBestV4DefaultRoute})
	}
	if o.GetHasBestV6DefaultRoute() != other.GetHasBestV6DefaultRoute() {
		res.Paths = append(res.Paths, &ProbeStatusNetworkInterface_FieldTerminalPath{selector: ProbeStatusNetworkInterface_FieldPathSelectorHasBestV6DefaultRoute})
	}
	return res
}

func (o *Probe_Status_NetworkInterface) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_NetworkInterface))
}

func (o *Probe_Status_NetworkInterface) Clone() *Probe_Status_NetworkInterface {
	if o == nil {
		return nil
	}
	result := &Probe_Status_NetworkInterface{}
	result.InterfaceName = o.InterfaceName
	result.IpAddressV4 = make([]string, len(o.IpAddressV4))
	for i, sourceValue := range o.IpAddressV4 {
		result.IpAddressV4[i] = sourceValue
	}
	result.ExternalIpAddressV4 = make([]string, len(o.ExternalIpAddressV4))
	for i, sourceValue := range o.ExternalIpAddressV4 {
		result.ExternalIpAddressV4[i] = sourceValue
	}
	result.IpAddressV6 = make([]string, len(o.IpAddressV6))
	for i, sourceValue := range o.IpAddressV6 {
		result.IpAddressV6[i] = sourceValue
	}
	result.ExternalIpAddressV6 = make([]string, len(o.ExternalIpAddressV6))
	for i, sourceValue := range o.ExternalIpAddressV6 {
		result.ExternalIpAddressV6[i] = sourceValue
	}
	result.HasV4DefaultRoute = o.HasV4DefaultRoute
	result.HasV6DefaultRoute = o.HasV6DefaultRoute
	result.HasBestV4DefaultRoute = o.HasBestV4DefaultRoute
	result.HasBestV6DefaultRoute = o.HasBestV6DefaultRoute
	return result
}

func (o *Probe_Status_NetworkInterface) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_NetworkInterface) Merge(source *Probe_Status_NetworkInterface) {
	o.InterfaceName = source.GetInterfaceName()
	for _, sourceValue := range source.GetIpAddressV4() {
		exists := false
		for _, currentValue := range o.IpAddressV4 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpAddressV4 = append(o.IpAddressV4, newDstElement)
		}
	}

	for _, sourceValue := range source.GetExternalIpAddressV4() {
		exists := false
		for _, currentValue := range o.ExternalIpAddressV4 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ExternalIpAddressV4 = append(o.ExternalIpAddressV4, newDstElement)
		}
	}

	for _, sourceValue := range source.GetIpAddressV6() {
		exists := false
		for _, currentValue := range o.IpAddressV6 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpAddressV6 = append(o.IpAddressV6, newDstElement)
		}
	}

	for _, sourceValue := range source.GetExternalIpAddressV6() {
		exists := false
		for _, currentValue := range o.ExternalIpAddressV6 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ExternalIpAddressV6 = append(o.ExternalIpAddressV6, newDstElement)
		}
	}

	o.HasV4DefaultRoute = source.GetHasV4DefaultRoute()
	o.HasV6DefaultRoute = source.GetHasV6DefaultRoute()
	o.HasBestV4DefaultRoute = source.GetHasBestV4DefaultRoute()
	o.HasBestV6DefaultRoute = source.GetHasBestV6DefaultRoute()
}

func (o *Probe_Status_NetworkInterface) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_NetworkInterface))
}

func (o *Probe_Status_ProxyConfig) GotenObjectExt() {}

func (o *Probe_Status_ProxyConfig) MakeFullFieldMask() *Probe_Status_ProxyConfig_FieldMask {
	return FullProbe_Status_ProxyConfig_FieldMask()
}

func (o *Probe_Status_ProxyConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_ProxyConfig_FieldMask()
}

func (o *Probe_Status_ProxyConfig) MakeDiffFieldMask(other *Probe_Status_ProxyConfig) *Probe_Status_ProxyConfig_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_ProxyConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_ProxyConfig_FieldMask()
	}

	res := &Probe_Status_ProxyConfig_FieldMask{}
	if o.GetHttpProxy() != other.GetHttpProxy() {
		res.Paths = append(res.Paths, &ProbeStatusProxyConfig_FieldTerminalPath{selector: ProbeStatusProxyConfig_FieldPathSelectorHttpProxy})
	}
	if o.GetHttpsProxy() != other.GetHttpsProxy() {
		res.Paths = append(res.Paths, &ProbeStatusProxyConfig_FieldTerminalPath{selector: ProbeStatusProxyConfig_FieldPathSelectorHttpsProxy})
	}
	if o.GetNoProxy() != other.GetNoProxy() {
		res.Paths = append(res.Paths, &ProbeStatusProxyConfig_FieldTerminalPath{selector: ProbeStatusProxyConfig_FieldPathSelectorNoProxy})
	}
	return res
}

func (o *Probe_Status_ProxyConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_ProxyConfig))
}

func (o *Probe_Status_ProxyConfig) Clone() *Probe_Status_ProxyConfig {
	if o == nil {
		return nil
	}
	result := &Probe_Status_ProxyConfig{}
	result.HttpProxy = o.HttpProxy
	result.HttpsProxy = o.HttpsProxy
	result.NoProxy = o.NoProxy
	return result
}

func (o *Probe_Status_ProxyConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_ProxyConfig) Merge(source *Probe_Status_ProxyConfig) {
	o.HttpProxy = source.GetHttpProxy()
	o.HttpsProxy = source.GetHttpsProxy()
	o.NoProxy = source.GetNoProxy()
}

func (o *Probe_Status_ProxyConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_ProxyConfig))
}

func (o *Probe_Status_System_OS) GotenObjectExt() {}

func (o *Probe_Status_System_OS) MakeFullFieldMask() *Probe_Status_System_OS_FieldMask {
	return FullProbe_Status_System_OS_FieldMask()
}

func (o *Probe_Status_System_OS) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_System_OS_FieldMask()
}

func (o *Probe_Status_System_OS) MakeDiffFieldMask(other *Probe_Status_System_OS) *Probe_Status_System_OS_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_System_OS_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_System_OS_FieldMask()
	}

	res := &Probe_Status_System_OS_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &ProbeStatusSystemOS_FieldTerminalPath{selector: ProbeStatusSystemOS_FieldPathSelectorName})
	}
	if o.GetVersion() != other.GetVersion() {
		res.Paths = append(res.Paths, &ProbeStatusSystemOS_FieldTerminalPath{selector: ProbeStatusSystemOS_FieldPathSelectorVersion})
	}
	if o.GetBuildVersion() != other.GetBuildVersion() {
		res.Paths = append(res.Paths, &ProbeStatusSystemOS_FieldTerminalPath{selector: ProbeStatusSystemOS_FieldPathSelectorBuildVersion})
	}
	if o.GetKernel() != other.GetKernel() {
		res.Paths = append(res.Paths, &ProbeStatusSystemOS_FieldTerminalPath{selector: ProbeStatusSystemOS_FieldPathSelectorKernel})
	}
	return res
}

func (o *Probe_Status_System_OS) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_System_OS))
}

func (o *Probe_Status_System_OS) Clone() *Probe_Status_System_OS {
	if o == nil {
		return nil
	}
	result := &Probe_Status_System_OS{}
	result.Name = o.Name
	result.Version = o.Version
	result.BuildVersion = o.BuildVersion
	result.Kernel = o.Kernel
	return result
}

func (o *Probe_Status_System_OS) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_System_OS) Merge(source *Probe_Status_System_OS) {
	o.Name = source.GetName()
	o.Version = source.GetVersion()
	o.BuildVersion = source.GetBuildVersion()
	o.Kernel = source.GetKernel()
}

func (o *Probe_Status_System_OS) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_System_OS))
}

func (o *Probe_Status_ActivationState_Session) GotenObjectExt() {}

func (o *Probe_Status_ActivationState_Session) MakeFullFieldMask() *Probe_Status_ActivationState_Session_FieldMask {
	return FullProbe_Status_ActivationState_Session_FieldMask()
}

func (o *Probe_Status_ActivationState_Session) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_ActivationState_Session_FieldMask()
}

func (o *Probe_Status_ActivationState_Session) MakeDiffFieldMask(other *Probe_Status_ActivationState_Session) *Probe_Status_ActivationState_Session_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_ActivationState_Session_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_ActivationState_Session_FieldMask()
	}

	res := &Probe_Status_ActivationState_Session_FieldMask{}
	if o.GetClientCookie() != other.GetClientCookie() {
		res.Paths = append(res.Paths, &ProbeStatusActivationStateSession_FieldTerminalPath{selector: ProbeStatusActivationStateSession_FieldPathSelectorClientCookie})
	}
	if !proto.Equal(o.GetLockDeadline(), other.GetLockDeadline()) {
		res.Paths = append(res.Paths, &ProbeStatusActivationStateSession_FieldTerminalPath{selector: ProbeStatusActivationStateSession_FieldPathSelectorLockDeadline})
	}
	return res
}

func (o *Probe_Status_ActivationState_Session) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_ActivationState_Session))
}

func (o *Probe_Status_ActivationState_Session) Clone() *Probe_Status_ActivationState_Session {
	if o == nil {
		return nil
	}
	result := &Probe_Status_ActivationState_Session{}
	result.ClientCookie = o.ClientCookie
	result.LockDeadline = proto.Clone(o.LockDeadline).(*timestamp.Timestamp)
	return result
}

func (o *Probe_Status_ActivationState_Session) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_ActivationState_Session) Merge(source *Probe_Status_ActivationState_Session) {
	o.ClientCookie = source.GetClientCookie()
	if source.GetLockDeadline() != nil {
		if o.LockDeadline == nil {
			o.LockDeadline = new(timestamp.Timestamp)
		}
		proto.Merge(o.LockDeadline, source.GetLockDeadline())
	}
}

func (o *Probe_Status_ActivationState_Session) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_ActivationState_Session))
}

func (o *Probe_Status_ActivationState_InvitationState) GotenObjectExt() {}

func (o *Probe_Status_ActivationState_InvitationState) MakeFullFieldMask() *Probe_Status_ActivationState_InvitationState_FieldMask {
	return FullProbe_Status_ActivationState_InvitationState_FieldMask()
}

func (o *Probe_Status_ActivationState_InvitationState) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullProbe_Status_ActivationState_InvitationState_FieldMask()
}

func (o *Probe_Status_ActivationState_InvitationState) MakeDiffFieldMask(other *Probe_Status_ActivationState_InvitationState) *Probe_Status_ActivationState_InvitationState_FieldMask {
	if o == nil && other == nil {
		return &Probe_Status_ActivationState_InvitationState_FieldMask{}
	}
	if o == nil || other == nil {
		return FullProbe_Status_ActivationState_InvitationState_FieldMask()
	}

	res := &Probe_Status_ActivationState_InvitationState_FieldMask{}
	if !proto.Equal(o.GetSentDate(), other.GetSentDate()) {
		res.Paths = append(res.Paths, &ProbeStatusActivationStateInvitationState_FieldTerminalPath{selector: ProbeStatusActivationStateInvitationState_FieldPathSelectorSentDate})
	}
	if o.GetSender() != other.GetSender() {
		res.Paths = append(res.Paths, &ProbeStatusActivationStateInvitationState_FieldTerminalPath{selector: ProbeStatusActivationStateInvitationState_FieldPathSelectorSender})
	}
	if o.GetSendFailureMessage() != other.GetSendFailureMessage() {
		res.Paths = append(res.Paths, &ProbeStatusActivationStateInvitationState_FieldTerminalPath{selector: ProbeStatusActivationStateInvitationState_FieldPathSelectorSendFailureMessage})
	}
	return res
}

func (o *Probe_Status_ActivationState_InvitationState) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Probe_Status_ActivationState_InvitationState))
}

func (o *Probe_Status_ActivationState_InvitationState) Clone() *Probe_Status_ActivationState_InvitationState {
	if o == nil {
		return nil
	}
	result := &Probe_Status_ActivationState_InvitationState{}
	result.SentDate = proto.Clone(o.SentDate).(*timestamp.Timestamp)
	result.Sender = o.Sender
	result.SendFailureMessage = o.SendFailureMessage
	return result
}

func (o *Probe_Status_ActivationState_InvitationState) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Probe_Status_ActivationState_InvitationState) Merge(source *Probe_Status_ActivationState_InvitationState) {
	if source.GetSentDate() != nil {
		if o.SentDate == nil {
			o.SentDate = new(timestamp.Timestamp)
		}
		proto.Merge(o.SentDate, source.GetSentDate())
	}
	o.Sender = source.GetSender()
	o.SendFailureMessage = source.GetSendFailureMessage()
}

func (o *Probe_Status_ActivationState_InvitationState) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Probe_Status_ActivationState_InvitationState))
}