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

// Code generated by protoc-gen-goten-object
// File: edgelq/logging/proto/v1/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 (
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	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 (
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &log_descriptor.LogDescriptor{}
	_ = &meta_service.Service{}
	_ = &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.GetServices()) == len(other.GetServices()) {
		for i, lValue := range o.GetServices() {
			rValue := other.GetServices()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorServices})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorServices})
	}

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

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

	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.Services = make([]string, len(o.Services))
	for i, sourceValue := range o.Services {
		result.Services[i] = sourceValue
	}
	result.Versions = make([]string, len(o.Versions))
	for i, sourceValue := range o.Versions {
		result.Versions[i] = sourceValue
	}
	result.Logs = make([]*Bucket_RequiredTypedLabels, len(o.Logs))
	for i, sourceValue := range o.Logs {
		result.Logs[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.GetServices() {
		exists := false
		for _, currentValue := range o.Services {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Services = append(o.Services, newDstElement)
		}
	}

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

	for _, sourceValue := range source.GetLogs() {
		exists := false
		for _, currentValue := range o.Logs {
			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.Logs = append(o.Logs, 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.GetDescriptors()) == len(other.GetDescriptors()) {
		for i, lValue := range o.GetDescriptors() {
			rValue := other.GetDescriptors()[i]
			if lValue.String() != rValue.String() {
				res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorDescriptors})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorDescriptors})
	}

	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.Descriptors = make([]*log_descriptor.Reference, len(o.Descriptors))
	for i, sourceValue := range o.Descriptors {
		if sourceValue == nil {
			result.Descriptors[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.Descriptors[i] = &log_descriptor.Reference{}
			if err := result.Descriptors[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	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.GetDescriptors() {
		exists := false
		for _, currentValue := range o.Descriptors {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *log_descriptor.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &log_descriptor.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.Descriptors = append(o.Descriptors, 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))
}