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

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

package bucket

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 (
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	meta "github.com/cloudwan/goten-sdk/types/meta"
)

// 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 (
	_ = &project.Project{}
	_ = &meta.Meta{}
)

func (o *Bucket) GotenObjectExt() {}

func (o *Bucket) MakeFullFieldMask() *Bucket_FieldMask {
	return FullBucket_FieldMask()
}

func (o *Bucket) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBucket_FieldMask()
}

func (o *Bucket) MakeDiffFieldMask(other *Bucket) *Bucket_FieldMask {
	if o == nil && other == nil {
		return &Bucket_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBucket_FieldMask()
	}

	res := &Bucket_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorName})
	}
	{
		subMask := o.GetMetadata().MakeDiffFieldMask(other.GetMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Bucket_FieldSubPath{selector: Bucket_FieldPathSelectorMetadata, subPath: subpath})
			}
		}
	}

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

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

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

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

func (o *Bucket) Clone() *Bucket {
	if o == nil {
		return nil
	}
	result := &Bucket{}
	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.Metadata = o.Metadata.Clone()
	result.Metrics = make([]*Bucket_RequiredTypedLabels, len(o.Metrics))
	for i, sourceValue := range o.Metrics {
		result.Metrics[i] = sourceValue.Clone()
	}
	result.Resources = make([]*Bucket_RequiredTypedLabels, len(o.Resources))
	for i, sourceValue := range o.Resources {
		result.Resources[i] = sourceValue.Clone()
	}
	result.RequiredAltKvs = make([]*Bucket_ResolvedKeysWithValues, len(o.RequiredAltKvs))
	for i, sourceValue := range o.RequiredAltKvs {
		result.RequiredAltKvs[i] = sourceValue.Clone()
	}
	return result
}

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

func (o *Bucket) Merge(source *Bucket) {
	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
	}
	if source.GetMetadata() != nil {
		if o.Metadata == nil {
			o.Metadata = new(meta.Meta)
		}
		o.Metadata.Merge(source.GetMetadata())
	}
	for _, sourceValue := range source.GetMetrics() {
		exists := false
		for _, currentValue := range o.Metrics {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Bucket_RequiredTypedLabels
			if sourceValue != nil {
				newDstElement = new(Bucket_RequiredTypedLabels)
				newDstElement.Merge(sourceValue)
			}
			o.Metrics = append(o.Metrics, newDstElement)
		}
	}

	for _, sourceValue := range source.GetResources() {
		exists := false
		for _, currentValue := range o.Resources {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Bucket_RequiredTypedLabels
			if sourceValue != nil {
				newDstElement = new(Bucket_RequiredTypedLabels)
				newDstElement.Merge(sourceValue)
			}
			o.Resources = append(o.Resources, newDstElement)
		}
	}

	for _, sourceValue := range source.GetRequiredAltKvs() {
		exists := false
		for _, currentValue := range o.RequiredAltKvs {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Bucket_ResolvedKeysWithValues
			if sourceValue != nil {
				newDstElement = new(Bucket_ResolvedKeysWithValues)
				newDstElement.Merge(sourceValue)
			}
			o.RequiredAltKvs = append(o.RequiredAltKvs, newDstElement)
		}
	}

}

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

func (o *Bucket_ResolvedValues) GotenObjectExt() {}

func (o *Bucket_ResolvedValues) MakeFullFieldMask() *Bucket_ResolvedValues_FieldMask {
	return FullBucket_ResolvedValues_FieldMask()
}

func (o *Bucket_ResolvedValues) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBucket_ResolvedValues_FieldMask()
}

func (o *Bucket_ResolvedValues) MakeDiffFieldMask(other *Bucket_ResolvedValues) *Bucket_ResolvedValues_FieldMask {
	if o == nil && other == nil {
		return &Bucket_ResolvedValues_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBucket_ResolvedValues_FieldMask()
	}

	res := &Bucket_ResolvedValues_FieldMask{}
	if o.GetKey() != other.GetKey() {
		res.Paths = append(res.Paths, &BucketResolvedValues_FieldTerminalPath{selector: BucketResolvedValues_FieldPathSelectorKey})
	}

	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, &BucketResolvedValues_FieldTerminalPath{selector: BucketResolvedValues_FieldPathSelectorValues})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BucketResolvedValues_FieldTerminalPath{selector: BucketResolvedValues_FieldPathSelectorValues})
	}
	return res
}

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

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

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

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

}

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

func (o *Bucket_ResolvedKeysWithValues) GotenObjectExt() {}

func (o *Bucket_ResolvedKeysWithValues) MakeFullFieldMask() *Bucket_ResolvedKeysWithValues_FieldMask {
	return FullBucket_ResolvedKeysWithValues_FieldMask()
}

func (o *Bucket_ResolvedKeysWithValues) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBucket_ResolvedKeysWithValues_FieldMask()
}

func (o *Bucket_ResolvedKeysWithValues) MakeDiffFieldMask(other *Bucket_ResolvedKeysWithValues) *Bucket_ResolvedKeysWithValues_FieldMask {
	if o == nil && other == nil {
		return &Bucket_ResolvedKeysWithValues_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBucket_ResolvedKeysWithValues_FieldMask()
	}

	res := &Bucket_ResolvedKeysWithValues_FieldMask{}

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

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

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

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

func (o *Bucket_ResolvedKeysWithValues) Merge(source *Bucket_ResolvedKeysWithValues) {
	for _, sourceValue := range source.GetResolvedKvs() {
		exists := false
		for _, currentValue := range o.ResolvedKvs {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Bucket_ResolvedValues
			if sourceValue != nil {
				newDstElement = new(Bucket_ResolvedValues)
				newDstElement.Merge(sourceValue)
			}
			o.ResolvedKvs = append(o.ResolvedKvs, newDstElement)
		}
	}

}

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

func (o *Bucket_RequiredTypedLabels) GotenObjectExt() {}

func (o *Bucket_RequiredTypedLabels) MakeFullFieldMask() *Bucket_RequiredTypedLabels_FieldMask {
	return FullBucket_RequiredTypedLabels_FieldMask()
}

func (o *Bucket_RequiredTypedLabels) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBucket_RequiredTypedLabels_FieldMask()
}

func (o *Bucket_RequiredTypedLabels) MakeDiffFieldMask(other *Bucket_RequiredTypedLabels) *Bucket_RequiredTypedLabels_FieldMask {
	if o == nil && other == nil {
		return &Bucket_RequiredTypedLabels_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBucket_RequiredTypedLabels_FieldMask()
	}

	res := &Bucket_RequiredTypedLabels_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, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorTypes})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_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, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorLabels})
	}
	return res
}

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

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

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

func (o *Bucket_RequiredTypedLabels) Merge(source *Bucket_RequiredTypedLabels) {
	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]*Bucket_RequiredTypedLabels_Strings, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			if sourceValue != nil {
				if o.Labels[key] == nil {
					o.Labels[key] = new(Bucket_RequiredTypedLabels_Strings)
				}
				o.Labels[key].Merge(sourceValue)
			}
		}
	}
}

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

func (o *Bucket_RequiredTypedLabels_Strings) GotenObjectExt() {}

func (o *Bucket_RequiredTypedLabels_Strings) MakeFullFieldMask() *Bucket_RequiredTypedLabels_Strings_FieldMask {
	return FullBucket_RequiredTypedLabels_Strings_FieldMask()
}

func (o *Bucket_RequiredTypedLabels_Strings) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBucket_RequiredTypedLabels_Strings_FieldMask()
}

func (o *Bucket_RequiredTypedLabels_Strings) MakeDiffFieldMask(other *Bucket_RequiredTypedLabels_Strings) *Bucket_RequiredTypedLabels_Strings_FieldMask {
	if o == nil && other == nil {
		return &Bucket_RequiredTypedLabels_Strings_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBucket_RequiredTypedLabels_Strings_FieldMask()
	}

	res := &Bucket_RequiredTypedLabels_Strings_FieldMask{}

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

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

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

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

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

}

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