github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v3/common/common.pb.object_ext.go

// Code generated by protoc-gen-goten-object
// File: edgelq/monitoring/proto/v3/common.proto
// DO NOT EDIT!!!

package common

import (
	"fmt"
	"sort"

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

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

// proto imports
import (
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
)

func (o *LabelDescriptor) GotenObjectExt() {}

func (o *LabelDescriptor) MakeFullFieldMask() *LabelDescriptor_FieldMask {
	return FullLabelDescriptor_FieldMask()
}

func (o *LabelDescriptor) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullLabelDescriptor_FieldMask()
}

func (o *LabelDescriptor) MakeDiffFieldMask(other *LabelDescriptor) *LabelDescriptor_FieldMask {
	if o == nil && other == nil {
		return &LabelDescriptor_FieldMask{}
	}
	if o == nil || other == nil {
		return FullLabelDescriptor_FieldMask()
	}

	res := &LabelDescriptor_FieldMask{}
	if o.GetKey() != other.GetKey() {
		res.Paths = append(res.Paths, &LabelDescriptor_FieldTerminalPath{selector: LabelDescriptor_FieldPathSelectorKey})
	}
	if o.GetValueType() != other.GetValueType() {
		res.Paths = append(res.Paths, &LabelDescriptor_FieldTerminalPath{selector: LabelDescriptor_FieldPathSelectorValueType})
	}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &LabelDescriptor_FieldTerminalPath{selector: LabelDescriptor_FieldPathSelectorDescription})
	}
	if o.GetDefaultValue() != other.GetDefaultValue() {
		res.Paths = append(res.Paths, &LabelDescriptor_FieldTerminalPath{selector: LabelDescriptor_FieldPathSelectorDefaultValue})
	}
	if o.GetDisabled() != other.GetDisabled() {
		res.Paths = append(res.Paths, &LabelDescriptor_FieldTerminalPath{selector: LabelDescriptor_FieldPathSelectorDisabled})
	}
	return res
}

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

func (o *LabelDescriptor) Clone() *LabelDescriptor {
	if o == nil {
		return nil
	}
	result := &LabelDescriptor{}
	result.Key = o.Key
	result.ValueType = o.ValueType
	result.Description = o.Description
	result.DefaultValue = o.DefaultValue
	result.Disabled = o.Disabled
	return result
}

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

func (o *LabelDescriptor) Merge(source *LabelDescriptor) {
	o.Key = source.GetKey()
	o.ValueType = source.GetValueType()
	o.Description = source.GetDescription()
	o.DefaultValue = source.GetDefaultValue()
	o.Disabled = source.GetDisabled()
}

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

func (o *LabelKeySet) GotenObjectExt() {}

func (o *LabelKeySet) MakeFullFieldMask() *LabelKeySet_FieldMask {
	return FullLabelKeySet_FieldMask()
}

func (o *LabelKeySet) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullLabelKeySet_FieldMask()
}

func (o *LabelKeySet) MakeDiffFieldMask(other *LabelKeySet) *LabelKeySet_FieldMask {
	if o == nil && other == nil {
		return &LabelKeySet_FieldMask{}
	}
	if o == nil || other == nil {
		return FullLabelKeySet_FieldMask()
	}

	res := &LabelKeySet_FieldMask{}

	if len(o.GetLabelKeys()) == len(other.GetLabelKeys()) {
		for i, lValue := range o.GetLabelKeys() {
			rValue := other.GetLabelKeys()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &LabelKeySet_FieldTerminalPath{selector: LabelKeySet_FieldPathSelectorLabelKeys})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &LabelKeySet_FieldTerminalPath{selector: LabelKeySet_FieldPathSelectorLabelKeys})
	}
	if o.GetWriteOnly() != other.GetWriteOnly() {
		res.Paths = append(res.Paths, &LabelKeySet_FieldTerminalPath{selector: LabelKeySet_FieldPathSelectorWriteOnly})
	}
	return res
}

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

func (o *LabelKeySet) Clone() *LabelKeySet {
	if o == nil {
		return nil
	}
	result := &LabelKeySet{}
	result.LabelKeys = make([]string, len(o.LabelKeys))
	for i, sourceValue := range o.LabelKeys {
		result.LabelKeys[i] = sourceValue
	}
	result.WriteOnly = o.WriteOnly
	return result
}

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

func (o *LabelKeySet) Merge(source *LabelKeySet) {
	for _, sourceValue := range source.GetLabelKeys() {
		exists := false
		for _, currentValue := range o.LabelKeys {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.LabelKeys = append(o.LabelKeys, newDstElement)
		}
	}

	o.WriteOnly = source.GetWriteOnly()
}

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

func (o *Distribution) GotenObjectExt() {}

func (o *Distribution) MakeFullFieldMask() *Distribution_FieldMask {
	return FullDistribution_FieldMask()
}

func (o *Distribution) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_FieldMask()
}

func (o *Distribution) MakeDiffFieldMask(other *Distribution) *Distribution_FieldMask {
	if o == nil && other == nil {
		return &Distribution_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_FieldMask()
	}

	res := &Distribution_FieldMask{}
	if o.GetCount() != other.GetCount() {
		res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorCount})
	}
	if o.GetMean() != other.GetMean() {
		res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorMean})
	}
	if o.GetSumOfSquaredDeviation() != other.GetSumOfSquaredDeviation() {
		res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorSumOfSquaredDeviation})
	}
	{
		subMask := o.GetRange().MakeDiffFieldMask(other.GetRange())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorRange})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Distribution_FieldSubPath{selector: Distribution_FieldPathSelectorRange, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetBucketOptions().MakeDiffFieldMask(other.GetBucketOptions())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorBucketOptions})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Distribution_FieldSubPath{selector: Distribution_FieldPathSelectorBucketOptions, subPath: subpath})
			}
		}
	}

	if len(o.GetBucketCounts()) == len(other.GetBucketCounts()) {
		for i, lValue := range o.GetBucketCounts() {
			rValue := other.GetBucketCounts()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorBucketCounts})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Distribution_FieldTerminalPath{selector: Distribution_FieldPathSelectorBucketCounts})
	}
	return res
}

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

func (o *Distribution) Clone() *Distribution {
	if o == nil {
		return nil
	}
	result := &Distribution{}
	result.Count = o.Count
	result.Mean = o.Mean
	result.SumOfSquaredDeviation = o.SumOfSquaredDeviation
	result.Range = o.Range.Clone()
	result.BucketOptions = o.BucketOptions.Clone()
	result.BucketCounts = make([]int64, len(o.BucketCounts))
	for i, sourceValue := range o.BucketCounts {
		result.BucketCounts[i] = sourceValue
	}
	return result
}

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

func (o *Distribution) Merge(source *Distribution) {
	o.Count = source.GetCount()
	o.Mean = source.GetMean()
	o.SumOfSquaredDeviation = source.GetSumOfSquaredDeviation()
	if source.GetRange() != nil {
		if o.Range == nil {
			o.Range = new(Distribution_Range)
		}
		o.Range.Merge(source.GetRange())
	}
	if source.GetBucketOptions() != nil {
		if o.BucketOptions == nil {
			o.BucketOptions = new(Distribution_BucketOptions)
		}
		o.BucketOptions.Merge(source.GetBucketOptions())
	}
	for _, sourceValue := range source.GetBucketCounts() {
		exists := false
		for _, currentValue := range o.BucketCounts {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement int64
			newDstElement = sourceValue
			o.BucketCounts = append(o.BucketCounts, newDstElement)
		}
	}

}

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

func (o *Distribution_Range) GotenObjectExt() {}

func (o *Distribution_Range) MakeFullFieldMask() *Distribution_Range_FieldMask {
	return FullDistribution_Range_FieldMask()
}

func (o *Distribution_Range) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_Range_FieldMask()
}

func (o *Distribution_Range) MakeDiffFieldMask(other *Distribution_Range) *Distribution_Range_FieldMask {
	if o == nil && other == nil {
		return &Distribution_Range_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_Range_FieldMask()
	}

	res := &Distribution_Range_FieldMask{}
	if o.GetMin() != other.GetMin() {
		res.Paths = append(res.Paths, &DistributionRange_FieldTerminalPath{selector: DistributionRange_FieldPathSelectorMin})
	}
	if o.GetMax() != other.GetMax() {
		res.Paths = append(res.Paths, &DistributionRange_FieldTerminalPath{selector: DistributionRange_FieldPathSelectorMax})
	}
	return res
}

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

func (o *Distribution_Range) Clone() *Distribution_Range {
	if o == nil {
		return nil
	}
	result := &Distribution_Range{}
	result.Min = o.Min
	result.Max = o.Max
	return result
}

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

func (o *Distribution_Range) Merge(source *Distribution_Range) {
	o.Min = source.GetMin()
	o.Max = source.GetMax()
}

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

func (o *Distribution_BucketOptions) GotenObjectExt() {}

func (o *Distribution_BucketOptions) MakeFullFieldMask() *Distribution_BucketOptions_FieldMask {
	return FullDistribution_BucketOptions_FieldMask()
}

func (o *Distribution_BucketOptions) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_BucketOptions_FieldMask()
}

func (o *Distribution_BucketOptions) MakeDiffFieldMask(other *Distribution_BucketOptions) *Distribution_BucketOptions_FieldMask {
	if o == nil && other == nil {
		return &Distribution_BucketOptions_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_BucketOptions_FieldMask()
	}

	res := &Distribution_BucketOptions_FieldMask{}
	{
		_, leftSelected := o.Options.(*Distribution_BucketOptions_LinearBuckets)
		_, rightSelected := other.Options.(*Distribution_BucketOptions_LinearBuckets)
		if leftSelected == rightSelected {
			subMask := o.GetLinearBuckets().MakeDiffFieldMask(other.GetLinearBuckets())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorLinearBuckets})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &DistributionBucketOptions_FieldSubPath{selector: DistributionBucketOptions_FieldPathSelectorLinearBuckets, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorLinearBuckets})
		}
	}
	{
		_, leftSelected := o.Options.(*Distribution_BucketOptions_ExponentialBuckets)
		_, rightSelected := other.Options.(*Distribution_BucketOptions_ExponentialBuckets)
		if leftSelected == rightSelected {
			subMask := o.GetExponentialBuckets().MakeDiffFieldMask(other.GetExponentialBuckets())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorExponentialBuckets})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &DistributionBucketOptions_FieldSubPath{selector: DistributionBucketOptions_FieldPathSelectorExponentialBuckets, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorExponentialBuckets})
		}
	}
	{
		_, leftSelected := o.Options.(*Distribution_BucketOptions_ExplicitBuckets)
		_, rightSelected := other.Options.(*Distribution_BucketOptions_ExplicitBuckets)
		if leftSelected == rightSelected {
			subMask := o.GetExplicitBuckets().MakeDiffFieldMask(other.GetExplicitBuckets())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorExplicitBuckets})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &DistributionBucketOptions_FieldSubPath{selector: DistributionBucketOptions_FieldPathSelectorExplicitBuckets, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorExplicitBuckets})
		}
	}
	{
		_, leftSelected := o.Options.(*Distribution_BucketOptions_DynamicBuckets)
		_, rightSelected := other.Options.(*Distribution_BucketOptions_DynamicBuckets)
		if leftSelected == rightSelected {
			subMask := o.GetDynamicBuckets().MakeDiffFieldMask(other.GetDynamicBuckets())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorDynamicBuckets})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &DistributionBucketOptions_FieldSubPath{selector: DistributionBucketOptions_FieldPathSelectorDynamicBuckets, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &DistributionBucketOptions_FieldTerminalPath{selector: DistributionBucketOptions_FieldPathSelectorDynamicBuckets})
		}
	}
	return res
}

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

func (o *Distribution_BucketOptions) Clone() *Distribution_BucketOptions {
	if o == nil {
		return nil
	}
	result := &Distribution_BucketOptions{}
	if o, ok := o.Options.(*Distribution_BucketOptions_LinearBuckets); ok {
		result.Options = (*Distribution_BucketOptions_LinearBuckets)(nil)
		if o != nil {
			result.Options = &Distribution_BucketOptions_LinearBuckets{}
			result := result.Options.(*Distribution_BucketOptions_LinearBuckets)
			result.LinearBuckets = o.LinearBuckets.Clone()
		}
	}
	if o, ok := o.Options.(*Distribution_BucketOptions_ExponentialBuckets); ok {
		result.Options = (*Distribution_BucketOptions_ExponentialBuckets)(nil)
		if o != nil {
			result.Options = &Distribution_BucketOptions_ExponentialBuckets{}
			result := result.Options.(*Distribution_BucketOptions_ExponentialBuckets)
			result.ExponentialBuckets = o.ExponentialBuckets.Clone()
		}
	}
	if o, ok := o.Options.(*Distribution_BucketOptions_ExplicitBuckets); ok {
		result.Options = (*Distribution_BucketOptions_ExplicitBuckets)(nil)
		if o != nil {
			result.Options = &Distribution_BucketOptions_ExplicitBuckets{}
			result := result.Options.(*Distribution_BucketOptions_ExplicitBuckets)
			result.ExplicitBuckets = o.ExplicitBuckets.Clone()
		}
	}
	if o, ok := o.Options.(*Distribution_BucketOptions_DynamicBuckets); ok {
		result.Options = (*Distribution_BucketOptions_DynamicBuckets)(nil)
		if o != nil {
			result.Options = &Distribution_BucketOptions_DynamicBuckets{}
			result := result.Options.(*Distribution_BucketOptions_DynamicBuckets)
			result.DynamicBuckets = o.DynamicBuckets.Clone()
		}
	}
	return result
}

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

func (o *Distribution_BucketOptions) Merge(source *Distribution_BucketOptions) {
	if source, ok := source.GetOptions().(*Distribution_BucketOptions_LinearBuckets); ok {
		if dstOneOf, ok := o.Options.(*Distribution_BucketOptions_LinearBuckets); !ok || dstOneOf == nil {
			o.Options = &Distribution_BucketOptions_LinearBuckets{}
		}
		if source != nil {
			o := o.Options.(*Distribution_BucketOptions_LinearBuckets)
			if source.LinearBuckets != nil {
				if o.LinearBuckets == nil {
					o.LinearBuckets = new(Distribution_BucketOptions_Linear)
				}
				o.LinearBuckets.Merge(source.LinearBuckets)
			}
		}
	}
	if source, ok := source.GetOptions().(*Distribution_BucketOptions_ExponentialBuckets); ok {
		if dstOneOf, ok := o.Options.(*Distribution_BucketOptions_ExponentialBuckets); !ok || dstOneOf == nil {
			o.Options = &Distribution_BucketOptions_ExponentialBuckets{}
		}
		if source != nil {
			o := o.Options.(*Distribution_BucketOptions_ExponentialBuckets)
			if source.ExponentialBuckets != nil {
				if o.ExponentialBuckets == nil {
					o.ExponentialBuckets = new(Distribution_BucketOptions_Exponential)
				}
				o.ExponentialBuckets.Merge(source.ExponentialBuckets)
			}
		}
	}
	if source, ok := source.GetOptions().(*Distribution_BucketOptions_ExplicitBuckets); ok {
		if dstOneOf, ok := o.Options.(*Distribution_BucketOptions_ExplicitBuckets); !ok || dstOneOf == nil {
			o.Options = &Distribution_BucketOptions_ExplicitBuckets{}
		}
		if source != nil {
			o := o.Options.(*Distribution_BucketOptions_ExplicitBuckets)
			if source.ExplicitBuckets != nil {
				if o.ExplicitBuckets == nil {
					o.ExplicitBuckets = new(Distribution_BucketOptions_Explicit)
				}
				o.ExplicitBuckets.Merge(source.ExplicitBuckets)
			}
		}
	}
	if source, ok := source.GetOptions().(*Distribution_BucketOptions_DynamicBuckets); ok {
		if dstOneOf, ok := o.Options.(*Distribution_BucketOptions_DynamicBuckets); !ok || dstOneOf == nil {
			o.Options = &Distribution_BucketOptions_DynamicBuckets{}
		}
		if source != nil {
			o := o.Options.(*Distribution_BucketOptions_DynamicBuckets)
			if source.DynamicBuckets != nil {
				if o.DynamicBuckets == nil {
					o.DynamicBuckets = new(Distribution_BucketOptions_Dynamic)
				}
				o.DynamicBuckets.Merge(source.DynamicBuckets)
			}
		}
	}
}

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

func (o *Distribution_BucketOptions_Linear) GotenObjectExt() {}

func (o *Distribution_BucketOptions_Linear) MakeFullFieldMask() *Distribution_BucketOptions_Linear_FieldMask {
	return FullDistribution_BucketOptions_Linear_FieldMask()
}

func (o *Distribution_BucketOptions_Linear) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_BucketOptions_Linear_FieldMask()
}

func (o *Distribution_BucketOptions_Linear) MakeDiffFieldMask(other *Distribution_BucketOptions_Linear) *Distribution_BucketOptions_Linear_FieldMask {
	if o == nil && other == nil {
		return &Distribution_BucketOptions_Linear_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_BucketOptions_Linear_FieldMask()
	}

	res := &Distribution_BucketOptions_Linear_FieldMask{}
	if o.GetNumFiniteBuckets() != other.GetNumFiniteBuckets() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsLinear_FieldTerminalPath{selector: DistributionBucketOptionsLinear_FieldPathSelectorNumFiniteBuckets})
	}
	if o.GetWidth() != other.GetWidth() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsLinear_FieldTerminalPath{selector: DistributionBucketOptionsLinear_FieldPathSelectorWidth})
	}
	if o.GetOffset() != other.GetOffset() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsLinear_FieldTerminalPath{selector: DistributionBucketOptionsLinear_FieldPathSelectorOffset})
	}
	return res
}

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

func (o *Distribution_BucketOptions_Linear) Clone() *Distribution_BucketOptions_Linear {
	if o == nil {
		return nil
	}
	result := &Distribution_BucketOptions_Linear{}
	result.NumFiniteBuckets = o.NumFiniteBuckets
	result.Width = o.Width
	result.Offset = o.Offset
	return result
}

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

func (o *Distribution_BucketOptions_Linear) Merge(source *Distribution_BucketOptions_Linear) {
	o.NumFiniteBuckets = source.GetNumFiniteBuckets()
	o.Width = source.GetWidth()
	o.Offset = source.GetOffset()
}

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

func (o *Distribution_BucketOptions_Exponential) GotenObjectExt() {}

func (o *Distribution_BucketOptions_Exponential) MakeFullFieldMask() *Distribution_BucketOptions_Exponential_FieldMask {
	return FullDistribution_BucketOptions_Exponential_FieldMask()
}

func (o *Distribution_BucketOptions_Exponential) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_BucketOptions_Exponential_FieldMask()
}

func (o *Distribution_BucketOptions_Exponential) MakeDiffFieldMask(other *Distribution_BucketOptions_Exponential) *Distribution_BucketOptions_Exponential_FieldMask {
	if o == nil && other == nil {
		return &Distribution_BucketOptions_Exponential_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_BucketOptions_Exponential_FieldMask()
	}

	res := &Distribution_BucketOptions_Exponential_FieldMask{}
	if o.GetNumFiniteBuckets() != other.GetNumFiniteBuckets() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsExponential_FieldTerminalPath{selector: DistributionBucketOptionsExponential_FieldPathSelectorNumFiniteBuckets})
	}
	if o.GetGrowthFactor() != other.GetGrowthFactor() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsExponential_FieldTerminalPath{selector: DistributionBucketOptionsExponential_FieldPathSelectorGrowthFactor})
	}
	if o.GetScale() != other.GetScale() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsExponential_FieldTerminalPath{selector: DistributionBucketOptionsExponential_FieldPathSelectorScale})
	}
	return res
}

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

func (o *Distribution_BucketOptions_Exponential) Clone() *Distribution_BucketOptions_Exponential {
	if o == nil {
		return nil
	}
	result := &Distribution_BucketOptions_Exponential{}
	result.NumFiniteBuckets = o.NumFiniteBuckets
	result.GrowthFactor = o.GrowthFactor
	result.Scale = o.Scale
	return result
}

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

func (o *Distribution_BucketOptions_Exponential) Merge(source *Distribution_BucketOptions_Exponential) {
	o.NumFiniteBuckets = source.GetNumFiniteBuckets()
	o.GrowthFactor = source.GetGrowthFactor()
	o.Scale = source.GetScale()
}

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

func (o *Distribution_BucketOptions_Explicit) GotenObjectExt() {}

func (o *Distribution_BucketOptions_Explicit) MakeFullFieldMask() *Distribution_BucketOptions_Explicit_FieldMask {
	return FullDistribution_BucketOptions_Explicit_FieldMask()
}

func (o *Distribution_BucketOptions_Explicit) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_BucketOptions_Explicit_FieldMask()
}

func (o *Distribution_BucketOptions_Explicit) MakeDiffFieldMask(other *Distribution_BucketOptions_Explicit) *Distribution_BucketOptions_Explicit_FieldMask {
	if o == nil && other == nil {
		return &Distribution_BucketOptions_Explicit_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_BucketOptions_Explicit_FieldMask()
	}

	res := &Distribution_BucketOptions_Explicit_FieldMask{}

	if len(o.GetBounds()) == len(other.GetBounds()) {
		for i, lValue := range o.GetBounds() {
			rValue := other.GetBounds()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DistributionBucketOptionsExplicit_FieldTerminalPath{selector: DistributionBucketOptionsExplicit_FieldPathSelectorBounds})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DistributionBucketOptionsExplicit_FieldTerminalPath{selector: DistributionBucketOptionsExplicit_FieldPathSelectorBounds})
	}
	return res
}

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

func (o *Distribution_BucketOptions_Explicit) Clone() *Distribution_BucketOptions_Explicit {
	if o == nil {
		return nil
	}
	result := &Distribution_BucketOptions_Explicit{}
	result.Bounds = make([]float64, len(o.Bounds))
	for i, sourceValue := range o.Bounds {
		result.Bounds[i] = sourceValue
	}
	return result
}

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

func (o *Distribution_BucketOptions_Explicit) Merge(source *Distribution_BucketOptions_Explicit) {
	for _, sourceValue := range source.GetBounds() {
		exists := false
		for _, currentValue := range o.Bounds {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement float64
			newDstElement = sourceValue
			o.Bounds = append(o.Bounds, newDstElement)
		}
	}

}

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

func (o *Distribution_BucketOptions_Dynamic) GotenObjectExt() {}

func (o *Distribution_BucketOptions_Dynamic) MakeFullFieldMask() *Distribution_BucketOptions_Dynamic_FieldMask {
	return FullDistribution_BucketOptions_Dynamic_FieldMask()
}

func (o *Distribution_BucketOptions_Dynamic) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDistribution_BucketOptions_Dynamic_FieldMask()
}

func (o *Distribution_BucketOptions_Dynamic) MakeDiffFieldMask(other *Distribution_BucketOptions_Dynamic) *Distribution_BucketOptions_Dynamic_FieldMask {
	if o == nil && other == nil {
		return &Distribution_BucketOptions_Dynamic_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDistribution_BucketOptions_Dynamic_FieldMask()
	}

	res := &Distribution_BucketOptions_Dynamic_FieldMask{}
	if o.GetCompression() != other.GetCompression() {
		res.Paths = append(res.Paths, &DistributionBucketOptionsDynamic_FieldTerminalPath{selector: DistributionBucketOptionsDynamic_FieldPathSelectorCompression})
	}

	if len(o.GetMeans()) == len(other.GetMeans()) {
		for i, lValue := range o.GetMeans() {
			rValue := other.GetMeans()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DistributionBucketOptionsDynamic_FieldTerminalPath{selector: DistributionBucketOptionsDynamic_FieldPathSelectorMeans})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DistributionBucketOptionsDynamic_FieldTerminalPath{selector: DistributionBucketOptionsDynamic_FieldPathSelectorMeans})
	}
	return res
}

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

func (o *Distribution_BucketOptions_Dynamic) Clone() *Distribution_BucketOptions_Dynamic {
	if o == nil {
		return nil
	}
	result := &Distribution_BucketOptions_Dynamic{}
	result.Compression = o.Compression
	result.Means = make([]float64, len(o.Means))
	for i, sourceValue := range o.Means {
		result.Means[i] = sourceValue
	}
	return result
}

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

func (o *Distribution_BucketOptions_Dynamic) Merge(source *Distribution_BucketOptions_Dynamic) {
	o.Compression = source.GetCompression()
	for _, sourceValue := range source.GetMeans() {
		exists := false
		for _, currentValue := range o.Means {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement float64
			newDstElement = sourceValue
			o.Means = append(o.Means, newDstElement)
		}
	}

}

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

func (o *TypedValue) GotenObjectExt() {}

func (o *TypedValue) MakeFullFieldMask() *TypedValue_FieldMask {
	return FullTypedValue_FieldMask()
}

func (o *TypedValue) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTypedValue_FieldMask()
}

func (o *TypedValue) MakeDiffFieldMask(other *TypedValue) *TypedValue_FieldMask {
	if o == nil && other == nil {
		return &TypedValue_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTypedValue_FieldMask()
	}

	res := &TypedValue_FieldMask{}
	{
		_, leftSelected := o.Value.(*TypedValue_BoolValue)
		_, rightSelected := other.Value.(*TypedValue_BoolValue)
		if leftSelected == rightSelected {
			if o.GetBoolValue() != other.GetBoolValue() {
				res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorBoolValue})
			}
		} else {
			res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorBoolValue})
		}
	}
	{
		_, leftSelected := o.Value.(*TypedValue_Int64Value)
		_, rightSelected := other.Value.(*TypedValue_Int64Value)
		if leftSelected == rightSelected {
			if o.GetInt64Value() != other.GetInt64Value() {
				res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorInt64Value})
			}
		} else {
			res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorInt64Value})
		}
	}
	{
		_, leftSelected := o.Value.(*TypedValue_DoubleValue)
		_, rightSelected := other.Value.(*TypedValue_DoubleValue)
		if leftSelected == rightSelected {
			if o.GetDoubleValue() != other.GetDoubleValue() {
				res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorDoubleValue})
			}
		} else {
			res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorDoubleValue})
		}
	}
	{
		_, leftSelected := o.Value.(*TypedValue_StringValue)
		_, rightSelected := other.Value.(*TypedValue_StringValue)
		if leftSelected == rightSelected {
			if o.GetStringValue() != other.GetStringValue() {
				res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorStringValue})
			}
		} else {
			res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorStringValue})
		}
	}
	{
		_, leftSelected := o.Value.(*TypedValue_DistributionValue)
		_, rightSelected := other.Value.(*TypedValue_DistributionValue)
		if leftSelected == rightSelected {
			subMask := o.GetDistributionValue().MakeDiffFieldMask(other.GetDistributionValue())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorDistributionValue})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &TypedValue_FieldSubPath{selector: TypedValue_FieldPathSelectorDistributionValue, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &TypedValue_FieldTerminalPath{selector: TypedValue_FieldPathSelectorDistributionValue})
		}
	}
	return res
}

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

func (o *TypedValue) Clone() *TypedValue {
	if o == nil {
		return nil
	}
	result := &TypedValue{}
	if o, ok := o.Value.(*TypedValue_BoolValue); ok {
		result.Value = (*TypedValue_BoolValue)(nil)
		if o != nil {
			result.Value = &TypedValue_BoolValue{}
			result := result.Value.(*TypedValue_BoolValue)
			result.BoolValue = o.BoolValue
		}
	}
	if o, ok := o.Value.(*TypedValue_Int64Value); ok {
		result.Value = (*TypedValue_Int64Value)(nil)
		if o != nil {
			result.Value = &TypedValue_Int64Value{}
			result := result.Value.(*TypedValue_Int64Value)
			result.Int64Value = o.Int64Value
		}
	}
	if o, ok := o.Value.(*TypedValue_DoubleValue); ok {
		result.Value = (*TypedValue_DoubleValue)(nil)
		if o != nil {
			result.Value = &TypedValue_DoubleValue{}
			result := result.Value.(*TypedValue_DoubleValue)
			result.DoubleValue = o.DoubleValue
		}
	}
	if o, ok := o.Value.(*TypedValue_StringValue); ok {
		result.Value = (*TypedValue_StringValue)(nil)
		if o != nil {
			result.Value = &TypedValue_StringValue{}
			result := result.Value.(*TypedValue_StringValue)
			result.StringValue = o.StringValue
		}
	}
	if o, ok := o.Value.(*TypedValue_DistributionValue); ok {
		result.Value = (*TypedValue_DistributionValue)(nil)
		if o != nil {
			result.Value = &TypedValue_DistributionValue{}
			result := result.Value.(*TypedValue_DistributionValue)
			result.DistributionValue = o.DistributionValue.Clone()
		}
	}
	return result
}

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

func (o *TypedValue) Merge(source *TypedValue) {
	if source, ok := source.GetValue().(*TypedValue_BoolValue); ok {
		if dstOneOf, ok := o.Value.(*TypedValue_BoolValue); !ok || dstOneOf == nil {
			o.Value = &TypedValue_BoolValue{}
		}
		if source != nil {
			o := o.Value.(*TypedValue_BoolValue)
			o.BoolValue = source.BoolValue
		}
	}
	if source, ok := source.GetValue().(*TypedValue_Int64Value); ok {
		if dstOneOf, ok := o.Value.(*TypedValue_Int64Value); !ok || dstOneOf == nil {
			o.Value = &TypedValue_Int64Value{}
		}
		if source != nil {
			o := o.Value.(*TypedValue_Int64Value)
			o.Int64Value = source.Int64Value
		}
	}
	if source, ok := source.GetValue().(*TypedValue_DoubleValue); ok {
		if dstOneOf, ok := o.Value.(*TypedValue_DoubleValue); !ok || dstOneOf == nil {
			o.Value = &TypedValue_DoubleValue{}
		}
		if source != nil {
			o := o.Value.(*TypedValue_DoubleValue)
			o.DoubleValue = source.DoubleValue
		}
	}
	if source, ok := source.GetValue().(*TypedValue_StringValue); ok {
		if dstOneOf, ok := o.Value.(*TypedValue_StringValue); !ok || dstOneOf == nil {
			o.Value = &TypedValue_StringValue{}
		}
		if source != nil {
			o := o.Value.(*TypedValue_StringValue)
			o.StringValue = source.StringValue
		}
	}
	if source, ok := source.GetValue().(*TypedValue_DistributionValue); ok {
		if dstOneOf, ok := o.Value.(*TypedValue_DistributionValue); !ok || dstOneOf == nil {
			o.Value = &TypedValue_DistributionValue{}
		}
		if source != nil {
			o := o.Value.(*TypedValue_DistributionValue)
			if source.DistributionValue != nil {
				if o.DistributionValue == nil {
					o.DistributionValue = new(Distribution)
				}
				o.DistributionValue.Merge(source.DistributionValue)
			}
		}
	}
}

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

func (o *TimeInterval) GotenObjectExt() {}

func (o *TimeInterval) MakeFullFieldMask() *TimeInterval_FieldMask {
	return FullTimeInterval_FieldMask()
}

func (o *TimeInterval) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTimeInterval_FieldMask()
}

func (o *TimeInterval) MakeDiffFieldMask(other *TimeInterval) *TimeInterval_FieldMask {
	if o == nil && other == nil {
		return &TimeInterval_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTimeInterval_FieldMask()
	}

	res := &TimeInterval_FieldMask{}
	if !proto.Equal(o.GetEndTime(), other.GetEndTime()) {
		res.Paths = append(res.Paths, &TimeInterval_FieldTerminalPath{selector: TimeInterval_FieldPathSelectorEndTime})
	}
	if !proto.Equal(o.GetStartTime(), other.GetStartTime()) {
		res.Paths = append(res.Paths, &TimeInterval_FieldTerminalPath{selector: TimeInterval_FieldPathSelectorStartTime})
	}
	return res
}

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

func (o *TimeInterval) Clone() *TimeInterval {
	if o == nil {
		return nil
	}
	result := &TimeInterval{}
	result.EndTime = proto.Clone(o.EndTime).(*timestamppb.Timestamp)
	result.StartTime = proto.Clone(o.StartTime).(*timestamppb.Timestamp)
	return result
}

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

func (o *TimeInterval) Merge(source *TimeInterval) {
	if source.GetEndTime() != nil {
		if o.EndTime == nil {
			o.EndTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.EndTime, source.GetEndTime())
	}
	if source.GetStartTime() != nil {
		if o.StartTime == nil {
			o.StartTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.StartTime, source.GetStartTime())
	}
}

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

func (o *TimeRange) GotenObjectExt() {}

func (o *TimeRange) MakeFullFieldMask() *TimeRange_FieldMask {
	return FullTimeRange_FieldMask()
}

func (o *TimeRange) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTimeRange_FieldMask()
}

func (o *TimeRange) MakeDiffFieldMask(other *TimeRange) *TimeRange_FieldMask {
	if o == nil && other == nil {
		return &TimeRange_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTimeRange_FieldMask()
	}

	res := &TimeRange_FieldMask{}
	if !proto.Equal(o.GetStartTime(), other.GetStartTime()) {
		res.Paths = append(res.Paths, &TimeRange_FieldTerminalPath{selector: TimeRange_FieldPathSelectorStartTime})
	}
	if !proto.Equal(o.GetEndTime(), other.GetEndTime()) {
		res.Paths = append(res.Paths, &TimeRange_FieldTerminalPath{selector: TimeRange_FieldPathSelectorEndTime})
	}
	return res
}

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

func (o *TimeRange) Clone() *TimeRange {
	if o == nil {
		return nil
	}
	result := &TimeRange{}
	result.StartTime = proto.Clone(o.StartTime).(*timestamppb.Timestamp)
	result.EndTime = proto.Clone(o.EndTime).(*timestamppb.Timestamp)
	return result
}

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

func (o *TimeRange) Merge(source *TimeRange) {
	if source.GetStartTime() != nil {
		if o.StartTime == nil {
			o.StartTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.StartTime, source.GetStartTime())
	}
	if source.GetEndTime() != nil {
		if o.EndTime == nil {
			o.EndTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.EndTime, source.GetEndTime())
	}
}

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

func (o *Aggregation) GotenObjectExt() {}

func (o *Aggregation) MakeFullFieldMask() *Aggregation_FieldMask {
	return FullAggregation_FieldMask()
}

func (o *Aggregation) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAggregation_FieldMask()
}

func (o *Aggregation) MakeDiffFieldMask(other *Aggregation) *Aggregation_FieldMask {
	if o == nil && other == nil {
		return &Aggregation_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAggregation_FieldMask()
	}

	res := &Aggregation_FieldMask{}
	if !proto.Equal(o.GetAlignmentPeriod(), other.GetAlignmentPeriod()) {
		res.Paths = append(res.Paths, &Aggregation_FieldTerminalPath{selector: Aggregation_FieldPathSelectorAlignmentPeriod})
	}
	if o.GetPerSeriesAligner() != other.GetPerSeriesAligner() {
		res.Paths = append(res.Paths, &Aggregation_FieldTerminalPath{selector: Aggregation_FieldPathSelectorPerSeriesAligner})
	}
	if o.GetCrossSeriesReducer() != other.GetCrossSeriesReducer() {
		res.Paths = append(res.Paths, &Aggregation_FieldTerminalPath{selector: Aggregation_FieldPathSelectorCrossSeriesReducer})
	}

	if len(o.GetGroupByFields()) == len(other.GetGroupByFields()) {
		for i, lValue := range o.GetGroupByFields() {
			rValue := other.GetGroupByFields()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &Aggregation_FieldTerminalPath{selector: Aggregation_FieldPathSelectorGroupByFields})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Aggregation_FieldTerminalPath{selector: Aggregation_FieldPathSelectorGroupByFields})
	}
	return res
}

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

func (o *Aggregation) Clone() *Aggregation {
	if o == nil {
		return nil
	}
	result := &Aggregation{}
	result.AlignmentPeriod = proto.Clone(o.AlignmentPeriod).(*durationpb.Duration)
	result.PerSeriesAligner = o.PerSeriesAligner
	result.CrossSeriesReducer = o.CrossSeriesReducer
	result.GroupByFields = make([]string, len(o.GroupByFields))
	for i, sourceValue := range o.GroupByFields {
		result.GroupByFields[i] = sourceValue
	}
	return result
}

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

func (o *Aggregation) Merge(source *Aggregation) {
	if source.GetAlignmentPeriod() != nil {
		if o.AlignmentPeriod == nil {
			o.AlignmentPeriod = new(durationpb.Duration)
		}
		proto.Merge(o.AlignmentPeriod, source.GetAlignmentPeriod())
	}
	o.PerSeriesAligner = source.GetPerSeriesAligner()
	o.CrossSeriesReducer = source.GetCrossSeriesReducer()
	for _, sourceValue := range source.GetGroupByFields() {
		exists := false
		for _, currentValue := range o.GroupByFields {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.GroupByFields = append(o.GroupByFields, newDstElement)
		}
	}

}

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

func (o *Pagination) GotenObjectExt() {}

func (o *Pagination) MakeFullFieldMask() *Pagination_FieldMask {
	return FullPagination_FieldMask()
}

func (o *Pagination) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullPagination_FieldMask()
}

func (o *Pagination) MakeDiffFieldMask(other *Pagination) *Pagination_FieldMask {
	if o == nil && other == nil {
		return &Pagination_FieldMask{}
	}
	if o == nil || other == nil {
		return FullPagination_FieldMask()
	}

	res := &Pagination_FieldMask{}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &Pagination_FieldTerminalPath{selector: Pagination_FieldPathSelectorView})
	}
	if o.GetFunction() != other.GetFunction() {
		res.Paths = append(res.Paths, &Pagination_FieldTerminalPath{selector: Pagination_FieldPathSelectorFunction})
	}
	if !proto.Equal(o.GetAlignmentPeriod(), other.GetAlignmentPeriod()) {
		res.Paths = append(res.Paths, &Pagination_FieldTerminalPath{selector: Pagination_FieldPathSelectorAlignmentPeriod})
	}
	if o.GetLimit() != other.GetLimit() {
		res.Paths = append(res.Paths, &Pagination_FieldTerminalPath{selector: Pagination_FieldPathSelectorLimit})
	}
	if o.GetOffset() != other.GetOffset() {
		res.Paths = append(res.Paths, &Pagination_FieldTerminalPath{selector: Pagination_FieldPathSelectorOffset})
	}
	return res
}

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

func (o *Pagination) Clone() *Pagination {
	if o == nil {
		return nil
	}
	result := &Pagination{}
	result.View = o.View
	result.Function = o.Function
	result.AlignmentPeriod = proto.Clone(o.AlignmentPeriod).(*durationpb.Duration)
	result.Limit = o.Limit
	result.Offset = o.Offset
	return result
}

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

func (o *Pagination) Merge(source *Pagination) {
	o.View = source.GetView()
	o.Function = source.GetFunction()
	if source.GetAlignmentPeriod() != nil {
		if o.AlignmentPeriod == nil {
			o.AlignmentPeriod = new(durationpb.Duration)
		}
		proto.Merge(o.AlignmentPeriod, source.GetAlignmentPeriod())
	}
	o.Limit = source.GetLimit()
	o.Offset = source.GetOffset()
}

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

func (o *Metric) GotenObjectExt() {}

func (o *Metric) MakeFullFieldMask() *Metric_FieldMask {
	return FullMetric_FieldMask()
}

func (o *Metric) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullMetric_FieldMask()
}

func (o *Metric) MakeDiffFieldMask(other *Metric) *Metric_FieldMask {
	if o == nil && other == nil {
		return &Metric_FieldMask{}
	}
	if o == nil || other == nil {
		return FullMetric_FieldMask()
	}

	res := &Metric_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &Metric_FieldTerminalPath{selector: Metric_FieldPathSelectorType})
	}

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

	if len(o.GetReducedLabels()) == len(other.GetReducedLabels()) {
		for i, lValue := range o.GetReducedLabels() {
			rValue := other.GetReducedLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &Metric_FieldTerminalPath{selector: Metric_FieldPathSelectorReducedLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Metric_FieldTerminalPath{selector: Metric_FieldPathSelectorReducedLabels})
	}
	return res
}

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

func (o *Metric) Clone() *Metric {
	if o == nil {
		return nil
	}
	result := &Metric{}
	result.Type = o.Type
	result.Labels = map[string]string{}
	for key, sourceValue := range o.Labels {
		result.Labels[key] = sourceValue
	}
	result.ReducedLabels = make([]string, len(o.ReducedLabels))
	for i, sourceValue := range o.ReducedLabels {
		result.ReducedLabels[i] = sourceValue
	}
	return result
}

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

func (o *Metric) Merge(source *Metric) {
	o.Type = source.GetType()
	if source.GetLabels() != nil {
		if o.Labels == nil {
			o.Labels = make(map[string]string, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			o.Labels[key] = sourceValue
		}
	}
	for _, sourceValue := range source.GetReducedLabels() {
		exists := false
		for _, currentValue := range o.ReducedLabels {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ReducedLabels = append(o.ReducedLabels, newDstElement)
		}
	}

}

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

func (o *MonitoredResource) GotenObjectExt() {}

func (o *MonitoredResource) MakeFullFieldMask() *MonitoredResource_FieldMask {
	return FullMonitoredResource_FieldMask()
}

func (o *MonitoredResource) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullMonitoredResource_FieldMask()
}

func (o *MonitoredResource) MakeDiffFieldMask(other *MonitoredResource) *MonitoredResource_FieldMask {
	if o == nil && other == nil {
		return &MonitoredResource_FieldMask{}
	}
	if o == nil || other == nil {
		return FullMonitoredResource_FieldMask()
	}

	res := &MonitoredResource_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &MonitoredResource_FieldTerminalPath{selector: MonitoredResource_FieldPathSelectorType})
	}

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

	if len(o.GetReducedLabels()) == len(other.GetReducedLabels()) {
		for i, lValue := range o.GetReducedLabels() {
			rValue := other.GetReducedLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &MonitoredResource_FieldTerminalPath{selector: MonitoredResource_FieldPathSelectorReducedLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &MonitoredResource_FieldTerminalPath{selector: MonitoredResource_FieldPathSelectorReducedLabels})
	}
	return res
}

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

func (o *MonitoredResource) Clone() *MonitoredResource {
	if o == nil {
		return nil
	}
	result := &MonitoredResource{}
	result.Type = o.Type
	result.Labels = map[string]string{}
	for key, sourceValue := range o.Labels {
		result.Labels[key] = sourceValue
	}
	result.ReducedLabels = make([]string, len(o.ReducedLabels))
	for i, sourceValue := range o.ReducedLabels {
		result.ReducedLabels[i] = sourceValue
	}
	return result
}

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

func (o *MonitoredResource) Merge(source *MonitoredResource) {
	o.Type = source.GetType()
	if source.GetLabels() != nil {
		if o.Labels == nil {
			o.Labels = make(map[string]string, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			o.Labels[key] = sourceValue
		}
	}
	for _, sourceValue := range source.GetReducedLabels() {
		exists := false
		for _, currentValue := range o.ReducedLabels {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ReducedLabels = append(o.ReducedLabels, newDstElement)
		}
	}

}

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

func (o *Strings) GotenObjectExt() {}

func (o *Strings) MakeFullFieldMask() *Strings_FieldMask {
	return FullStrings_FieldMask()
}

func (o *Strings) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullStrings_FieldMask()
}

func (o *Strings) MakeDiffFieldMask(other *Strings) *Strings_FieldMask {
	if o == nil && other == nil {
		return &Strings_FieldMask{}
	}
	if o == nil || other == nil {
		return FullStrings_FieldMask()
	}

	res := &Strings_FieldMask{}

	if len(o.GetValues()) == len(other.GetValues()) {
		for i, lValue := range o.GetValues() {
			rValue := other.GetValues()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &Strings_FieldTerminalPath{selector: Strings_FieldPathSelectorValues})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Strings_FieldTerminalPath{selector: Strings_FieldPathSelectorValues})
	}
	return res
}

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

func (o *Strings) Clone() *Strings {
	if o == nil {
		return nil
	}
	result := &Strings{}
	result.Values = make([]string, len(o.Values))
	for i, sourceValue := range o.Values {
		result.Values[i] = sourceValue
	}
	return result
}

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

func (o *Strings) Merge(source *Strings) {
	for _, sourceValue := range source.GetValues() {
		exists := false
		for _, currentValue := range o.Values {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Values = append(o.Values, newDstElement)
		}
	}

}

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

func (o *MonitoredResourceSelector) GotenObjectExt() {}

func (o *MonitoredResourceSelector) MakeFullFieldMask() *MonitoredResourceSelector_FieldMask {
	return FullMonitoredResourceSelector_FieldMask()
}

func (o *MonitoredResourceSelector) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullMonitoredResourceSelector_FieldMask()
}

func (o *MonitoredResourceSelector) MakeDiffFieldMask(other *MonitoredResourceSelector) *MonitoredResourceSelector_FieldMask {
	if o == nil && other == nil {
		return &MonitoredResourceSelector_FieldMask{}
	}
	if o == nil || other == nil {
		return FullMonitoredResourceSelector_FieldMask()
	}

	res := &MonitoredResourceSelector_FieldMask{}

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

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

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

func (o *MonitoredResourceSelector) Clone() *MonitoredResourceSelector {
	if o == nil {
		return nil
	}
	result := &MonitoredResourceSelector{}
	result.Types = make([]string, len(o.Types))
	for i, sourceValue := range o.Types {
		result.Types[i] = sourceValue
	}
	result.Labels = map[string]*Strings{}
	for key, sourceValue := range o.Labels {
		result.Labels[key] = sourceValue.Clone()
	}
	return result
}

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

func (o *MonitoredResourceSelector) Merge(source *MonitoredResourceSelector) {
	for _, sourceValue := range source.GetTypes() {
		exists := false
		for _, currentValue := range o.Types {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Types = append(o.Types, newDstElement)
		}
	}

	if source.GetLabels() != nil {
		if o.Labels == nil {
			o.Labels = make(map[string]*Strings, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			if sourceValue != nil {
				if o.Labels[key] == nil {
					o.Labels[key] = new(Strings)
				}
				o.Labels[key].Merge(sourceValue)
			}
		}
	}
}

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

func (o *MetricSelector) GotenObjectExt() {}

func (o *MetricSelector) MakeFullFieldMask() *MetricSelector_FieldMask {
	return FullMetricSelector_FieldMask()
}

func (o *MetricSelector) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullMetricSelector_FieldMask()
}

func (o *MetricSelector) MakeDiffFieldMask(other *MetricSelector) *MetricSelector_FieldMask {
	if o == nil && other == nil {
		return &MetricSelector_FieldMask{}
	}
	if o == nil || other == nil {
		return FullMetricSelector_FieldMask()
	}

	res := &MetricSelector_FieldMask{}

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

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

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

func (o *MetricSelector) Clone() *MetricSelector {
	if o == nil {
		return nil
	}
	result := &MetricSelector{}
	result.Types = make([]string, len(o.Types))
	for i, sourceValue := range o.Types {
		result.Types[i] = sourceValue
	}
	result.Labels = map[string]*Strings{}
	for key, sourceValue := range o.Labels {
		result.Labels[key] = sourceValue.Clone()
	}
	return result
}

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

func (o *MetricSelector) Merge(source *MetricSelector) {
	for _, sourceValue := range source.GetTypes() {
		exists := false
		for _, currentValue := range o.Types {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Types = append(o.Types, newDstElement)
		}
	}

	if source.GetLabels() != nil {
		if o.Labels == nil {
			o.Labels = make(map[string]*Strings, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			if sourceValue != nil {
				if o.Labels[key] == nil {
					o.Labels[key] = new(Strings)
				}
				o.Labels[key].Merge(sourceValue)
			}
		}
	}
}

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

func (o *TimeSeriesSelector) GotenObjectExt() {}

func (o *TimeSeriesSelector) MakeFullFieldMask() *TimeSeriesSelector_FieldMask {
	return FullTimeSeriesSelector_FieldMask()
}

func (o *TimeSeriesSelector) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTimeSeriesSelector_FieldMask()
}

func (o *TimeSeriesSelector) MakeDiffFieldMask(other *TimeSeriesSelector) *TimeSeriesSelector_FieldMask {
	if o == nil && other == nil {
		return &TimeSeriesSelector_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTimeSeriesSelector_FieldMask()
	}

	res := &TimeSeriesSelector_FieldMask{}
	{
		subMask := o.GetMetric().MakeDiffFieldMask(other.GetMetric())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TimeSeriesSelector_FieldTerminalPath{selector: TimeSeriesSelector_FieldPathSelectorMetric})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TimeSeriesSelector_FieldSubPath{selector: TimeSeriesSelector_FieldPathSelectorMetric, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetResource().MakeDiffFieldMask(other.GetResource())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TimeSeriesSelector_FieldTerminalPath{selector: TimeSeriesSelector_FieldPathSelectorResource})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TimeSeriesSelector_FieldSubPath{selector: TimeSeriesSelector_FieldPathSelectorResource, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *TimeSeriesSelector) Clone() *TimeSeriesSelector {
	if o == nil {
		return nil
	}
	result := &TimeSeriesSelector{}
	result.Metric = o.Metric.Clone()
	result.Resource = o.Resource.Clone()
	return result
}

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

func (o *TimeSeriesSelector) Merge(source *TimeSeriesSelector) {
	if source.GetMetric() != nil {
		if o.Metric == nil {
			o.Metric = new(MetricSelector)
		}
		o.Metric.Merge(source.GetMetric())
	}
	if source.GetResource() != nil {
		if o.Resource == nil {
			o.Resource = new(MonitoredResourceSelector)
		}
		o.Resource.Merge(source.GetResource())
	}
}

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