github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/ts_entry/ts_entry.pb.object_ext.go

// Code generated by protoc-gen-goten-object
// File: edgelq/alerting/proto/v1/ts_entry.proto
// DO NOT EDIT!!!

package ts_entry

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 (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	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 (
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
)

func (o *TsEntry) GotenObjectExt() {}

func (o *TsEntry) MakeFullFieldMask() *TsEntry_FieldMask {
	return FullTsEntry_FieldMask()
}

func (o *TsEntry) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_FieldMask()
}

func (o *TsEntry) MakeDiffFieldMask(other *TsEntry) *TsEntry_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_FieldMask()
	}

	res := &TsEntry_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorName})
	}
	{
		subMask := o.GetMetadata().MakeDiffFieldMask(other.GetMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorMetadata, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetInfo().MakeDiffFieldMask(other.GetInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetState().MakeDiffFieldMask(other.GetState())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorState})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorState, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetInternal().MakeDiffFieldMask(other.GetInternal())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInternal})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInternal, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *TsEntry) Clone() *TsEntry {
	if o == nil {
		return nil
	}
	result := &TsEntry{}
	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.Info = o.Info.Clone()
	result.State = o.State.Clone()
	result.Internal = o.Internal.Clone()
	return result
}

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

func (o *TsEntry) Merge(source *TsEntry) {
	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())
	}
	if source.GetInfo() != nil {
		if o.Info == nil {
			o.Info = new(TsEntry_Info)
		}
		o.Info.Merge(source.GetInfo())
	}
	if source.GetState() != nil {
		if o.State == nil {
			o.State = new(TsEntry_State)
		}
		o.State.Merge(source.GetState())
	}
	if source.GetInternal() != nil {
		if o.Internal == nil {
			o.Internal = new(TsEntry_Internal)
		}
		o.Internal.Merge(source.GetInternal())
	}
}

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

func (o *TsEntry_Info) GotenObjectExt() {}

func (o *TsEntry_Info) MakeFullFieldMask() *TsEntry_Info_FieldMask {
	return FullTsEntry_Info_FieldMask()
}

func (o *TsEntry_Info) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_Info_FieldMask()
}

func (o *TsEntry_Info) MakeDiffFieldMask(other *TsEntry_Info) *TsEntry_Info_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_Info_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_Info_FieldMask()
	}

	res := &TsEntry_Info_FieldMask{}
	{
		subMask := o.GetAlertingResource().MakeDiffFieldMask(other.GetAlertingResource())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntryInfo_FieldSubPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource, subPath: subpath})
			}
		}
	}
	if string(o.GetGroupByKey()) != string(other.GetGroupByKey()) {
		res.Paths = append(res.Paths, &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorGroupByKey})
	}

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

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

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

func (o *TsEntry_Info) Clone() *TsEntry_Info {
	if o == nil {
		return nil
	}
	result := &TsEntry_Info{}
	result.AlertingResource = o.AlertingResource.Clone()
	result.GroupByKey = make([]byte, len(o.GroupByKey))
	for i, bt := range o.GroupByKey {
		result.GroupByKey[i] = bt
	}
	result.CommonMetricLabels = map[string]string{}
	for key, sourceValue := range o.CommonMetricLabels {
		result.CommonMetricLabels[key] = sourceValue
	}
	result.CommonResourceLabels = map[string]string{}
	for key, sourceValue := range o.CommonResourceLabels {
		result.CommonResourceLabels[key] = sourceValue
	}
	return result
}

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

func (o *TsEntry_Info) Merge(source *TsEntry_Info) {
	if source.GetAlertingResource() != nil {
		if o.AlertingResource == nil {
			o.AlertingResource = new(meta.OwnerReference)
		}
		o.AlertingResource.Merge(source.GetAlertingResource())
	}
	o.GroupByKey = make([]byte, len(source.GetGroupByKey()))
	for i, bt := range source.GetGroupByKey() {
		o.GroupByKey[i] = bt
	}
	if source.GetCommonMetricLabels() != nil {
		if o.CommonMetricLabels == nil {
			o.CommonMetricLabels = make(map[string]string, len(source.GetCommonMetricLabels()))
		}
		for key, sourceValue := range source.GetCommonMetricLabels() {
			o.CommonMetricLabels[key] = sourceValue
		}
	}
	if source.GetCommonResourceLabels() != nil {
		if o.CommonResourceLabels == nil {
			o.CommonResourceLabels = make(map[string]string, len(source.GetCommonResourceLabels()))
		}
		for key, sourceValue := range source.GetCommonResourceLabels() {
			o.CommonResourceLabels[key] = sourceValue
		}
	}
}

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

func (o *TsEntry_State) GotenObjectExt() {}

func (o *TsEntry_State) MakeFullFieldMask() *TsEntry_State_FieldMask {
	return FullTsEntry_State_FieldMask()
}

func (o *TsEntry_State) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_State_FieldMask()
}

func (o *TsEntry_State) MakeDiffFieldMask(other *TsEntry_State) *TsEntry_State_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_State_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_State_FieldMask()
	}

	res := &TsEntry_State_FieldMask{}

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

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

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

func (o *TsEntry_State) Clone() *TsEntry_State {
	if o == nil {
		return nil
	}
	result := &TsEntry_State{}
	result.Models = make([]*TsEntry_State_AnomalyModelData, len(o.Models))
	for i, sourceValue := range o.Models {
		result.Models[i] = sourceValue.Clone()
	}
	result.Thresholds = make([]*TsEntry_State_AdaptiveThresholdInfo, len(o.Thresholds))
	for i, sourceValue := range o.Thresholds {
		result.Thresholds[i] = sourceValue.Clone()
	}
	return result
}

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

func (o *TsEntry_State) Merge(source *TsEntry_State) {
	for _, sourceValue := range source.GetModels() {
		exists := false
		for _, currentValue := range o.Models {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *TsEntry_State_AnomalyModelData
			if sourceValue != nil {
				newDstElement = new(TsEntry_State_AnomalyModelData)
				newDstElement.Merge(sourceValue)
			}
			o.Models = append(o.Models, newDstElement)
		}
	}

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

}

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

func (o *TsEntry_Internal) GotenObjectExt() {}

func (o *TsEntry_Internal) MakeFullFieldMask() *TsEntry_Internal_FieldMask {
	return FullTsEntry_Internal_FieldMask()
}

func (o *TsEntry_Internal) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_Internal_FieldMask()
}

func (o *TsEntry_Internal) MakeDiffFieldMask(other *TsEntry_Internal) *TsEntry_Internal_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_Internal_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_Internal_FieldMask()
	}

	res := &TsEntry_Internal_FieldMask{}
	if o.GetAlertingLocation() != other.GetAlertingLocation() {
		res.Paths = append(res.Paths, &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorAlertingLocation})
	}
	if o.GetSpecGeneration() != other.GetSpecGeneration() {
		res.Paths = append(res.Paths, &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorSpecGeneration})
	}
	return res
}

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

func (o *TsEntry_Internal) Clone() *TsEntry_Internal {
	if o == nil {
		return nil
	}
	result := &TsEntry_Internal{}
	result.AlertingLocation = o.AlertingLocation
	result.SpecGeneration = o.SpecGeneration
	return result
}

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

func (o *TsEntry_Internal) Merge(source *TsEntry_Internal) {
	o.AlertingLocation = source.GetAlertingLocation()
	o.SpecGeneration = source.GetSpecGeneration()
}

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

func (o *TsEntry_State_AnomalyModelData) GotenObjectExt() {}

func (o *TsEntry_State_AnomalyModelData) MakeFullFieldMask() *TsEntry_State_AnomalyModelData_FieldMask {
	return FullTsEntry_State_AnomalyModelData_FieldMask()
}

func (o *TsEntry_State_AnomalyModelData) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_State_AnomalyModelData_FieldMask()
}

func (o *TsEntry_State_AnomalyModelData) MakeDiffFieldMask(other *TsEntry_State_AnomalyModelData) *TsEntry_State_AnomalyModelData_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_State_AnomalyModelData_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_State_AnomalyModelData_FieldMask()
	}

	res := &TsEntry_State_AnomalyModelData_FieldMask{}
	if !proto.Equal(o.GetAnalysisWindow(), other.GetAnalysisWindow()) {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow})
	}
	if string(o.GetModelData()) != string(other.GetModelData()) {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorModelData})
	}

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

	if len(o.GetTrainingMaxErr()) == len(other.GetTrainingMaxErr()) {
		for i, lValue := range o.GetTrainingMaxErr() {
			rValue := other.GetTrainingMaxErr()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr})
	}
	if o.GetTrainedInEpochs() != other.GetTrainedInEpochs() {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs})
	}
	if !proto.Equal(o.GetTrainedIn(), other.GetTrainedIn()) {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn})
	}
	if !proto.Equal(o.GetTrainAfter(), other.GetTrainAfter()) {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter})
	}
	{
		subMask := o.GetTrainingPeriod().MakeDiffFieldMask(other.GetTrainingPeriod())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntryStateAnomalyModelData_FieldSubPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod, subPath: subpath})
			}
		}
	}

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

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

func (o *TsEntry_State_AnomalyModelData) Clone() *TsEntry_State_AnomalyModelData {
	if o == nil {
		return nil
	}
	result := &TsEntry_State_AnomalyModelData{}
	result.AnalysisWindow = proto.Clone(o.AnalysisWindow).(*durationpb.Duration)
	result.ModelData = make([]byte, len(o.ModelData))
	for i, bt := range o.ModelData {
		result.ModelData[i] = bt
	}
	result.TrainingMeanErr = make([]float64, len(o.TrainingMeanErr))
	for i, sourceValue := range o.TrainingMeanErr {
		result.TrainingMeanErr[i] = sourceValue
	}
	result.TrainingMaxErr = make([]float64, len(o.TrainingMaxErr))
	for i, sourceValue := range o.TrainingMaxErr {
		result.TrainingMaxErr[i] = sourceValue
	}
	result.TrainedInEpochs = o.TrainedInEpochs
	result.TrainedIn = proto.Clone(o.TrainedIn).(*durationpb.Duration)
	result.TrainAfter = proto.Clone(o.TrainAfter).(*timestamppb.Timestamp)
	result.TrainingPeriod = o.TrainingPeriod.Clone()
	result.Sensitiveness = make([]*TsEntry_State_AnomalyModelSensitiveness, len(o.Sensitiveness))
	for i, sourceValue := range o.Sensitiveness {
		result.Sensitiveness[i] = sourceValue.Clone()
	}
	return result
}

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

func (o *TsEntry_State_AnomalyModelData) Merge(source *TsEntry_State_AnomalyModelData) {
	if source.GetAnalysisWindow() != nil {
		if o.AnalysisWindow == nil {
			o.AnalysisWindow = new(durationpb.Duration)
		}
		proto.Merge(o.AnalysisWindow, source.GetAnalysisWindow())
	}
	o.ModelData = make([]byte, len(source.GetModelData()))
	for i, bt := range source.GetModelData() {
		o.ModelData[i] = bt
	}
	for _, sourceValue := range source.GetTrainingMeanErr() {
		exists := false
		for _, currentValue := range o.TrainingMeanErr {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement float64
			newDstElement = sourceValue
			o.TrainingMeanErr = append(o.TrainingMeanErr, newDstElement)
		}
	}

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

	o.TrainedInEpochs = source.GetTrainedInEpochs()
	if source.GetTrainedIn() != nil {
		if o.TrainedIn == nil {
			o.TrainedIn = new(durationpb.Duration)
		}
		proto.Merge(o.TrainedIn, source.GetTrainedIn())
	}
	if source.GetTrainAfter() != nil {
		if o.TrainAfter == nil {
			o.TrainAfter = new(timestamppb.Timestamp)
		}
		proto.Merge(o.TrainAfter, source.GetTrainAfter())
	}
	if source.GetTrainingPeriod() != nil {
		if o.TrainingPeriod == nil {
			o.TrainingPeriod = new(monitoring_common.TimeInterval)
		}
		o.TrainingPeriod.Merge(source.GetTrainingPeriod())
	}
	for _, sourceValue := range source.GetSensitiveness() {
		exists := false
		for _, currentValue := range o.Sensitiveness {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *TsEntry_State_AnomalyModelSensitiveness
			if sourceValue != nil {
				newDstElement = new(TsEntry_State_AnomalyModelSensitiveness)
				newDstElement.Merge(sourceValue)
			}
			o.Sensitiveness = append(o.Sensitiveness, newDstElement)
		}
	}

}

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

func (o *TsEntry_State_AnomalyModelSensitiveness) GotenObjectExt() {}

func (o *TsEntry_State_AnomalyModelSensitiveness) MakeFullFieldMask() *TsEntry_State_AnomalyModelSensitiveness_FieldMask {
	return FullTsEntry_State_AnomalyModelSensitiveness_FieldMask()
}

func (o *TsEntry_State_AnomalyModelSensitiveness) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_State_AnomalyModelSensitiveness_FieldMask()
}

func (o *TsEntry_State_AnomalyModelSensitiveness) MakeDiffFieldMask(other *TsEntry_State_AnomalyModelSensitiveness) *TsEntry_State_AnomalyModelSensitiveness_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_State_AnomalyModelSensitiveness_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_State_AnomalyModelSensitiveness_FieldMask()
	}

	res := &TsEntry_State_AnomalyModelSensitiveness_FieldMask{}
	if o.GetQueryName() != other.GetQueryName() {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName})
	}
	if o.GetAnomalyThreshold() != other.GetAnomalyThreshold() {
		res.Paths = append(res.Paths, &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold})
	}
	return res
}

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

func (o *TsEntry_State_AnomalyModelSensitiveness) Clone() *TsEntry_State_AnomalyModelSensitiveness {
	if o == nil {
		return nil
	}
	result := &TsEntry_State_AnomalyModelSensitiveness{}
	result.QueryName = o.QueryName
	result.AnomalyThreshold = o.AnomalyThreshold
	return result
}

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

func (o *TsEntry_State_AnomalyModelSensitiveness) Merge(source *TsEntry_State_AnomalyModelSensitiveness) {
	o.QueryName = source.GetQueryName()
	o.AnomalyThreshold = source.GetAnomalyThreshold()
}

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

func (o *TsEntry_State_AdaptiveThresholdInfo) GotenObjectExt() {}

func (o *TsEntry_State_AdaptiveThresholdInfo) MakeFullFieldMask() *TsEntry_State_AdaptiveThresholdInfo_FieldMask {
	return FullTsEntry_State_AdaptiveThresholdInfo_FieldMask()
}

func (o *TsEntry_State_AdaptiveThresholdInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullTsEntry_State_AdaptiveThresholdInfo_FieldMask()
}

func (o *TsEntry_State_AdaptiveThresholdInfo) MakeDiffFieldMask(other *TsEntry_State_AdaptiveThresholdInfo) *TsEntry_State_AdaptiveThresholdInfo_FieldMask {
	if o == nil && other == nil {
		return &TsEntry_State_AdaptiveThresholdInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullTsEntry_State_AdaptiveThresholdInfo_FieldMask()
	}

	res := &TsEntry_State_AdaptiveThresholdInfo_FieldMask{}
	if o.GetQueryName() != other.GetQueryName() {
		res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName})
	}
	{
		subMask := o.GetLower().MakeDiffFieldMask(other.GetLower())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetUpper().MakeDiffFieldMask(other.GetUpper())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetNextCheck(), other.GetNextCheck()) {
		res.Paths = append(res.Paths, &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck})
	}
	return res
}

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

func (o *TsEntry_State_AdaptiveThresholdInfo) Clone() *TsEntry_State_AdaptiveThresholdInfo {
	if o == nil {
		return nil
	}
	result := &TsEntry_State_AdaptiveThresholdInfo{}
	result.QueryName = o.QueryName
	result.Lower = o.Lower.Clone()
	result.Upper = o.Upper.Clone()
	result.NextCheck = proto.Clone(o.NextCheck).(*timestamppb.Timestamp)
	return result
}

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

func (o *TsEntry_State_AdaptiveThresholdInfo) Merge(source *TsEntry_State_AdaptiveThresholdInfo) {
	o.QueryName = source.GetQueryName()
	if source.GetLower() != nil {
		if o.Lower == nil {
			o.Lower = new(rcommon.AlertingThreshold)
		}
		o.Lower.Merge(source.GetLower())
	}
	if source.GetUpper() != nil {
		if o.Upper == nil {
			o.Upper = new(rcommon.AlertingThreshold)
		}
		o.Upper.Merge(source.GetUpper())
	}
	if source.GetNextCheck() != nil {
		if o.NextCheck == nil {
			o.NextCheck = new(timestamppb.Timestamp)
		}
		proto.Merge(o.NextCheck, source.GetNextCheck())
	}
}

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