phantom_time_serie_service.pb.object_ext.go

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

package phantom_time_serie_client

import (
	"fmt"
	"sort"

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

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

// proto imports
import (
	phantom_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/phantom_time_serie"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	view "github.com/cloudwan/goten-sdk/runtime/api/view"
	watch_type "github.com/cloudwan/goten-sdk/runtime/api/watch_type"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &phantom_time_serie.PhantomTimeSerie{}
	_ = &project.Project{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = view.View(0)
	_ = watch_type.WatchType(0)
)

func (o *GetPhantomTimeSerieRequest) GotenObjectExt() {}

func (o *GetPhantomTimeSerieRequest) MakeFullFieldMask() *GetPhantomTimeSerieRequest_FieldMask {
	return FullGetPhantomTimeSerieRequest_FieldMask()
}

func (o *GetPhantomTimeSerieRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullGetPhantomTimeSerieRequest_FieldMask()
}

func (o *GetPhantomTimeSerieRequest) MakeDiffFieldMask(other *GetPhantomTimeSerieRequest) *GetPhantomTimeSerieRequest_FieldMask {
	if o == nil && other == nil {
		return &GetPhantomTimeSerieRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullGetPhantomTimeSerieRequest_FieldMask()
	}

	res := &GetPhantomTimeSerieRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorName})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *GetPhantomTimeSerieRequest) Clone() *GetPhantomTimeSerieRequest {
	if o == nil {
		return nil
	}
	result := &GetPhantomTimeSerieRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &phantom_time_serie.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.View = o.View
	return result
}

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

func (o *GetPhantomTimeSerieRequest) Merge(source *GetPhantomTimeSerieRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &phantom_time_serie.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *BatchGetPhantomTimeSeriesRequest) GotenObjectExt() {}

func (o *BatchGetPhantomTimeSeriesRequest) MakeFullFieldMask() *BatchGetPhantomTimeSeriesRequest_FieldMask {
	return FullBatchGetPhantomTimeSeriesRequest_FieldMask()
}

func (o *BatchGetPhantomTimeSeriesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBatchGetPhantomTimeSeriesRequest_FieldMask()
}

func (o *BatchGetPhantomTimeSeriesRequest) MakeDiffFieldMask(other *BatchGetPhantomTimeSeriesRequest) *BatchGetPhantomTimeSeriesRequest_FieldMask {
	if o == nil && other == nil {
		return &BatchGetPhantomTimeSeriesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBatchGetPhantomTimeSeriesRequest_FieldMask()
	}

	res := &BatchGetPhantomTimeSeriesRequest_FieldMask{}

	if len(o.GetNames()) == len(other.GetNames()) {
		for i, lValue := range o.GetNames() {
			rValue := other.GetNames()[i]
			if lValue.String() != rValue.String() {
				res.Paths = append(res.Paths, &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *BatchGetPhantomTimeSeriesRequest) Clone() *BatchGetPhantomTimeSeriesRequest {
	if o == nil {
		return nil
	}
	result := &BatchGetPhantomTimeSeriesRequest{}
	result.Names = make([]*phantom_time_serie.Reference, len(o.Names))
	for i, sourceValue := range o.Names {
		if sourceValue == nil {
			result.Names[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.Names[i] = &phantom_time_serie.Reference{}
			if err := result.Names[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.View = o.View
	return result
}

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

func (o *BatchGetPhantomTimeSeriesRequest) Merge(source *BatchGetPhantomTimeSeriesRequest) {
	for _, sourceValue := range source.GetNames() {
		exists := false
		for _, currentValue := range o.Names {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *phantom_time_serie.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &phantom_time_serie.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.Names = append(o.Names, newDstElement)
		}
	}

	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *BatchGetPhantomTimeSeriesResponse) GotenObjectExt() {}

func (o *BatchGetPhantomTimeSeriesResponse) MakeFullFieldMask() *BatchGetPhantomTimeSeriesResponse_FieldMask {
	return FullBatchGetPhantomTimeSeriesResponse_FieldMask()
}

func (o *BatchGetPhantomTimeSeriesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBatchGetPhantomTimeSeriesResponse_FieldMask()
}

func (o *BatchGetPhantomTimeSeriesResponse) MakeDiffFieldMask(other *BatchGetPhantomTimeSeriesResponse) *BatchGetPhantomTimeSeriesResponse_FieldMask {
	if o == nil && other == nil {
		return &BatchGetPhantomTimeSeriesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBatchGetPhantomTimeSeriesResponse_FieldMask()
	}

	res := &BatchGetPhantomTimeSeriesResponse_FieldMask{}

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

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

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

func (o *BatchGetPhantomTimeSeriesResponse) Clone() *BatchGetPhantomTimeSeriesResponse {
	if o == nil {
		return nil
	}
	result := &BatchGetPhantomTimeSeriesResponse{}
	result.PhantomTimeSeries = make([]*phantom_time_serie.PhantomTimeSerie, len(o.PhantomTimeSeries))
	for i, sourceValue := range o.PhantomTimeSeries {
		result.PhantomTimeSeries[i] = sourceValue.Clone()
	}
	result.Missing = make([]*phantom_time_serie.Reference, len(o.Missing))
	for i, sourceValue := range o.Missing {
		if sourceValue == nil {
			result.Missing[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.Missing[i] = &phantom_time_serie.Reference{}
			if err := result.Missing[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	return result
}

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

func (o *BatchGetPhantomTimeSeriesResponse) Merge(source *BatchGetPhantomTimeSeriesResponse) {
	for _, sourceValue := range source.GetPhantomTimeSeries() {
		exists := false
		for _, currentValue := range o.PhantomTimeSeries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *phantom_time_serie.PhantomTimeSerie
			if sourceValue != nil {
				newDstElement = new(phantom_time_serie.PhantomTimeSerie)
				newDstElement.Merge(sourceValue)
			}
			o.PhantomTimeSeries = append(o.PhantomTimeSeries, newDstElement)
		}
	}

	for _, sourceValue := range source.GetMissing() {
		exists := false
		for _, currentValue := range o.Missing {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *phantom_time_serie.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &phantom_time_serie.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.Missing = append(o.Missing, newDstElement)
		}
	}

}

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

func (o *ListPhantomTimeSeriesRequest) GotenObjectExt() {}

func (o *ListPhantomTimeSeriesRequest) MakeFullFieldMask() *ListPhantomTimeSeriesRequest_FieldMask {
	return FullListPhantomTimeSeriesRequest_FieldMask()
}

func (o *ListPhantomTimeSeriesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullListPhantomTimeSeriesRequest_FieldMask()
}

func (o *ListPhantomTimeSeriesRequest) MakeDiffFieldMask(other *ListPhantomTimeSeriesRequest) *ListPhantomTimeSeriesRequest_FieldMask {
	if o == nil && other == nil {
		return &ListPhantomTimeSeriesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullListPhantomTimeSeriesRequest_FieldMask()
	}

	res := &ListPhantomTimeSeriesRequest_FieldMask{}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorParent})
	}
	if o.GetPageSize() != other.GetPageSize() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize})
	}
	if o.GetPageToken().String() != other.GetPageToken().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken})
	}
	if o.GetOrderBy().String() != other.GetOrderBy().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy})
	}
	if o.GetFilter().String() != other.GetFilter().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorFilter})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorView})
	}
	if o.GetIncludePagingInfo() != other.GetIncludePagingInfo() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo})
	}
	return res
}

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

func (o *ListPhantomTimeSeriesRequest) Clone() *ListPhantomTimeSeriesRequest {
	if o == nil {
		return nil
	}
	result := &ListPhantomTimeSeriesRequest{}
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &phantom_time_serie.ParentName{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PageSize = o.PageSize
	if o.PageToken == nil {
		result.PageToken = nil
	} else if data, err := o.PageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PageToken = &phantom_time_serie.PagerCursor{}
		if err := result.PageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.OrderBy == nil {
		result.OrderBy = nil
	} else if data, err := o.OrderBy.ProtoString(); err != nil {
		panic(err)
	} else {
		result.OrderBy = &phantom_time_serie.OrderBy{}
		if err := result.OrderBy.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.Filter == nil {
		result.Filter = nil
	} else if data, err := o.Filter.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Filter = &phantom_time_serie.Filter{}
		if err := result.Filter.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.View = o.View
	result.IncludePagingInfo = o.IncludePagingInfo
	return result
}

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

func (o *ListPhantomTimeSeriesRequest) Merge(source *ListPhantomTimeSeriesRequest) {
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &phantom_time_serie.ParentName{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	o.PageSize = source.GetPageSize()
	if source.GetPageToken() != nil {
		if data, err := source.GetPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PageToken = &phantom_time_serie.PagerCursor{}
			if err := o.PageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PageToken = nil
	}
	if source.GetOrderBy() != nil {
		if data, err := source.GetOrderBy().ProtoString(); err != nil {
			panic(err)
		} else {
			o.OrderBy = &phantom_time_serie.OrderBy{}
			if err := o.OrderBy.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.OrderBy = nil
	}
	if source.GetFilter() != nil {
		if data, err := source.GetFilter().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Filter = &phantom_time_serie.Filter{}
			if err := o.Filter.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Filter = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
	o.IncludePagingInfo = source.GetIncludePagingInfo()
}

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

func (o *ListPhantomTimeSeriesResponse) GotenObjectExt() {}

func (o *ListPhantomTimeSeriesResponse) MakeFullFieldMask() *ListPhantomTimeSeriesResponse_FieldMask {
	return FullListPhantomTimeSeriesResponse_FieldMask()
}

func (o *ListPhantomTimeSeriesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullListPhantomTimeSeriesResponse_FieldMask()
}

func (o *ListPhantomTimeSeriesResponse) MakeDiffFieldMask(other *ListPhantomTimeSeriesResponse) *ListPhantomTimeSeriesResponse_FieldMask {
	if o == nil && other == nil {
		return &ListPhantomTimeSeriesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullListPhantomTimeSeriesResponse_FieldMask()
	}

	res := &ListPhantomTimeSeriesResponse_FieldMask{}

	if len(o.GetPhantomTimeSeries()) == len(other.GetPhantomTimeSeries()) {
		for i, lValue := range o.GetPhantomTimeSeries() {
			rValue := other.GetPhantomTimeSeries()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries})
	}
	if o.GetPrevPageToken().String() != other.GetPrevPageToken().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken})
	}
	if o.GetNextPageToken().String() != other.GetNextPageToken().String() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken})
	}
	if o.GetCurrentOffset() != other.GetCurrentOffset() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset})
	}
	if o.GetTotalResultsCount() != other.GetTotalResultsCount() {
		res.Paths = append(res.Paths, &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount})
	}
	return res
}

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

func (o *ListPhantomTimeSeriesResponse) Clone() *ListPhantomTimeSeriesResponse {
	if o == nil {
		return nil
	}
	result := &ListPhantomTimeSeriesResponse{}
	result.PhantomTimeSeries = make([]*phantom_time_serie.PhantomTimeSerie, len(o.PhantomTimeSeries))
	for i, sourceValue := range o.PhantomTimeSeries {
		result.PhantomTimeSeries[i] = sourceValue.Clone()
	}
	if o.PrevPageToken == nil {
		result.PrevPageToken = nil
	} else if data, err := o.PrevPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PrevPageToken = &phantom_time_serie.PagerCursor{}
		if err := result.PrevPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.NextPageToken == nil {
		result.NextPageToken = nil
	} else if data, err := o.NextPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.NextPageToken = &phantom_time_serie.PagerCursor{}
		if err := result.NextPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.CurrentOffset = o.CurrentOffset
	result.TotalResultsCount = o.TotalResultsCount
	return result
}

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

func (o *ListPhantomTimeSeriesResponse) Merge(source *ListPhantomTimeSeriesResponse) {
	for _, sourceValue := range source.GetPhantomTimeSeries() {
		exists := false
		for _, currentValue := range o.PhantomTimeSeries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *phantom_time_serie.PhantomTimeSerie
			if sourceValue != nil {
				newDstElement = new(phantom_time_serie.PhantomTimeSerie)
				newDstElement.Merge(sourceValue)
			}
			o.PhantomTimeSeries = append(o.PhantomTimeSeries, newDstElement)
		}
	}

	if source.GetPrevPageToken() != nil {
		if data, err := source.GetPrevPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PrevPageToken = &phantom_time_serie.PagerCursor{}
			if err := o.PrevPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PrevPageToken = nil
	}
	if source.GetNextPageToken() != nil {
		if data, err := source.GetNextPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.NextPageToken = &phantom_time_serie.PagerCursor{}
			if err := o.NextPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.NextPageToken = nil
	}
	o.CurrentOffset = source.GetCurrentOffset()
	o.TotalResultsCount = source.GetTotalResultsCount()
}

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

func (o *WatchPhantomTimeSerieRequest) GotenObjectExt() {}

func (o *WatchPhantomTimeSerieRequest) MakeFullFieldMask() *WatchPhantomTimeSerieRequest_FieldMask {
	return FullWatchPhantomTimeSerieRequest_FieldMask()
}

func (o *WatchPhantomTimeSerieRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchPhantomTimeSerieRequest_FieldMask()
}

func (o *WatchPhantomTimeSerieRequest) MakeDiffFieldMask(other *WatchPhantomTimeSerieRequest) *WatchPhantomTimeSerieRequest_FieldMask {
	if o == nil && other == nil {
		return &WatchPhantomTimeSerieRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchPhantomTimeSerieRequest_FieldMask()
	}

	res := &WatchPhantomTimeSerieRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorName})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *WatchPhantomTimeSerieRequest) Clone() *WatchPhantomTimeSerieRequest {
	if o == nil {
		return nil
	}
	result := &WatchPhantomTimeSerieRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &phantom_time_serie.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.View = o.View
	return result
}

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

func (o *WatchPhantomTimeSerieRequest) Merge(source *WatchPhantomTimeSerieRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &phantom_time_serie.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *WatchPhantomTimeSerieResponse) GotenObjectExt() {}

func (o *WatchPhantomTimeSerieResponse) MakeFullFieldMask() *WatchPhantomTimeSerieResponse_FieldMask {
	return FullWatchPhantomTimeSerieResponse_FieldMask()
}

func (o *WatchPhantomTimeSerieResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchPhantomTimeSerieResponse_FieldMask()
}

func (o *WatchPhantomTimeSerieResponse) MakeDiffFieldMask(other *WatchPhantomTimeSerieResponse) *WatchPhantomTimeSerieResponse_FieldMask {
	if o == nil && other == nil {
		return &WatchPhantomTimeSerieResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchPhantomTimeSerieResponse_FieldMask()
	}

	res := &WatchPhantomTimeSerieResponse_FieldMask{}
	if !proto.Equal(o.GetChange(), other.GetChange()) {
		res.Paths = append(res.Paths, &WatchPhantomTimeSerieResponse_FieldTerminalPath{selector: WatchPhantomTimeSerieResponse_FieldPathSelectorChange})
	}
	return res
}

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

func (o *WatchPhantomTimeSerieResponse) Clone() *WatchPhantomTimeSerieResponse {
	if o == nil {
		return nil
	}
	result := &WatchPhantomTimeSerieResponse{}
	result.Change = proto.Clone(o.Change).(*phantom_time_serie.PhantomTimeSerieChange)
	return result
}

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

func (o *WatchPhantomTimeSerieResponse) Merge(source *WatchPhantomTimeSerieResponse) {
	if source.GetChange() != nil {
		if o.Change == nil {
			o.Change = new(phantom_time_serie.PhantomTimeSerieChange)
		}
		proto.Merge(o.Change, source.GetChange())
	}
}

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

func (o *WatchPhantomTimeSeriesRequest) GotenObjectExt() {}

func (o *WatchPhantomTimeSeriesRequest) MakeFullFieldMask() *WatchPhantomTimeSeriesRequest_FieldMask {
	return FullWatchPhantomTimeSeriesRequest_FieldMask()
}

func (o *WatchPhantomTimeSeriesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchPhantomTimeSeriesRequest_FieldMask()
}

func (o *WatchPhantomTimeSeriesRequest) MakeDiffFieldMask(other *WatchPhantomTimeSeriesRequest) *WatchPhantomTimeSeriesRequest_FieldMask {
	if o == nil && other == nil {
		return &WatchPhantomTimeSeriesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchPhantomTimeSeriesRequest_FieldMask()
	}

	res := &WatchPhantomTimeSeriesRequest_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorType})
	}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorParent})
	}
	if o.GetPageSize() != other.GetPageSize() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize})
	}
	if o.GetPageToken().String() != other.GetPageToken().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken})
	}
	if o.GetOrderBy().String() != other.GetOrderBy().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy})
	}
	if o.GetResumeToken() != other.GetResumeToken() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken})
	}
	if !proto.Equal(o.GetStartingTime(), other.GetStartingTime()) {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime})
	}
	if o.GetFilter().String() != other.GetFilter().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorView})
	}
	if o.GetMaxChunkSize() != other.GetMaxChunkSize() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize})
	}
	return res
}

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

func (o *WatchPhantomTimeSeriesRequest) Clone() *WatchPhantomTimeSeriesRequest {
	if o == nil {
		return nil
	}
	result := &WatchPhantomTimeSeriesRequest{}
	result.Type = o.Type
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &phantom_time_serie.ParentReference{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PageSize = o.PageSize
	if o.PageToken == nil {
		result.PageToken = nil
	} else if data, err := o.PageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PageToken = &phantom_time_serie.PagerCursor{}
		if err := result.PageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.OrderBy == nil {
		result.OrderBy = nil
	} else if data, err := o.OrderBy.ProtoString(); err != nil {
		panic(err)
	} else {
		result.OrderBy = &phantom_time_serie.OrderBy{}
		if err := result.OrderBy.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.ResumeToken = o.ResumeToken
	result.StartingTime = proto.Clone(o.StartingTime).(*timestamp.Timestamp)
	if o.Filter == nil {
		result.Filter = nil
	} else if data, err := o.Filter.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Filter = &phantom_time_serie.Filter{}
		if err := result.Filter.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.View = o.View
	result.MaxChunkSize = o.MaxChunkSize
	return result
}

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

func (o *WatchPhantomTimeSeriesRequest) Merge(source *WatchPhantomTimeSeriesRequest) {
	o.Type = source.GetType()
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &phantom_time_serie.ParentReference{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	o.PageSize = source.GetPageSize()
	if source.GetPageToken() != nil {
		if data, err := source.GetPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PageToken = &phantom_time_serie.PagerCursor{}
			if err := o.PageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PageToken = nil
	}
	if source.GetOrderBy() != nil {
		if data, err := source.GetOrderBy().ProtoString(); err != nil {
			panic(err)
		} else {
			o.OrderBy = &phantom_time_serie.OrderBy{}
			if err := o.OrderBy.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.OrderBy = nil
	}
	o.ResumeToken = source.GetResumeToken()
	if source.GetStartingTime() != nil {
		if o.StartingTime == nil {
			o.StartingTime = new(timestamp.Timestamp)
		}
		proto.Merge(o.StartingTime, source.GetStartingTime())
	}
	if source.GetFilter() != nil {
		if data, err := source.GetFilter().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Filter = &phantom_time_serie.Filter{}
			if err := o.Filter.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Filter = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
	o.MaxChunkSize = source.GetMaxChunkSize()
}

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

func (o *WatchPhantomTimeSeriesResponse) GotenObjectExt() {}

func (o *WatchPhantomTimeSeriesResponse) MakeFullFieldMask() *WatchPhantomTimeSeriesResponse_FieldMask {
	return FullWatchPhantomTimeSeriesResponse_FieldMask()
}

func (o *WatchPhantomTimeSeriesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchPhantomTimeSeriesResponse_FieldMask()
}

func (o *WatchPhantomTimeSeriesResponse) MakeDiffFieldMask(other *WatchPhantomTimeSeriesResponse) *WatchPhantomTimeSeriesResponse_FieldMask {
	if o == nil && other == nil {
		return &WatchPhantomTimeSeriesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchPhantomTimeSeriesResponse_FieldMask()
	}

	res := &WatchPhantomTimeSeriesResponse_FieldMask{}

	if len(o.GetPhantomTimeSerieChanges()) == len(other.GetPhantomTimeSerieChanges()) {
		for i, lValue := range o.GetPhantomTimeSerieChanges() {
			rValue := other.GetPhantomTimeSerieChanges()[i]
			if !proto.Equal(lValue, rValue) {
				res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges})
	}
	if o.GetIsCurrent() != other.GetIsCurrent() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent})
	}
	{
		subMask := o.GetPageTokenChange().MakeDiffFieldMask(other.GetPageTokenChange())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldSubPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange, subPath: subpath})
			}
		}
	}
	if o.GetResumeToken() != other.GetResumeToken() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken})
	}
	if o.GetSnapshotSize() != other.GetSnapshotSize() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize})
	}
	if o.GetIsSoftReset() != other.GetIsSoftReset() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset})
	}
	if o.GetIsHardReset() != other.GetIsHardReset() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset})
	}
	return res
}

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

func (o *WatchPhantomTimeSeriesResponse) Clone() *WatchPhantomTimeSeriesResponse {
	if o == nil {
		return nil
	}
	result := &WatchPhantomTimeSeriesResponse{}
	result.PhantomTimeSerieChanges = make([]*phantom_time_serie.PhantomTimeSerieChange, len(o.PhantomTimeSerieChanges))
	for i, sourceValue := range o.PhantomTimeSerieChanges {
		result.PhantomTimeSerieChanges[i] = proto.Clone(sourceValue).(*phantom_time_serie.PhantomTimeSerieChange)
	}
	result.IsCurrent = o.IsCurrent
	result.PageTokenChange = o.PageTokenChange.Clone()
	result.ResumeToken = o.ResumeToken
	result.SnapshotSize = o.SnapshotSize
	result.IsSoftReset = o.IsSoftReset
	result.IsHardReset = o.IsHardReset
	return result
}

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

func (o *WatchPhantomTimeSeriesResponse) Merge(source *WatchPhantomTimeSeriesResponse) {
	for _, sourceValue := range source.GetPhantomTimeSerieChanges() {
		exists := false
		for _, currentValue := range o.PhantomTimeSerieChanges {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *phantom_time_serie.PhantomTimeSerieChange
			if sourceValue != nil {
				newDstElement = new(phantom_time_serie.PhantomTimeSerieChange)
				proto.Merge(newDstElement, sourceValue)
			}
			o.PhantomTimeSerieChanges = append(o.PhantomTimeSerieChanges, newDstElement)
		}
	}

	o.IsCurrent = source.GetIsCurrent()
	if source.GetPageTokenChange() != nil {
		if o.PageTokenChange == nil {
			o.PageTokenChange = new(WatchPhantomTimeSeriesResponse_PageTokenChange)
		}
		o.PageTokenChange.Merge(source.GetPageTokenChange())
	}
	o.ResumeToken = source.GetResumeToken()
	o.SnapshotSize = source.GetSnapshotSize()
	o.IsSoftReset = source.GetIsSoftReset()
	o.IsHardReset = source.GetIsHardReset()
}

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

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) GotenObjectExt() {}

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) MakeFullFieldMask() *WatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask {
	return FullWatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask()
}

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask()
}

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) MakeDiffFieldMask(other *WatchPhantomTimeSeriesResponse_PageTokenChange) *WatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask {
	if o == nil && other == nil {
		return &WatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask()
	}

	res := &WatchPhantomTimeSeriesResponse_PageTokenChange_FieldMask{}
	if o.GetPrevPageToken().String() != other.GetPrevPageToken().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken})
	}
	if o.GetNextPageToken().String() != other.GetNextPageToken().String() {
		res.Paths = append(res.Paths, &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken})
	}
	return res
}

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

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) Clone() *WatchPhantomTimeSeriesResponse_PageTokenChange {
	if o == nil {
		return nil
	}
	result := &WatchPhantomTimeSeriesResponse_PageTokenChange{}
	if o.PrevPageToken == nil {
		result.PrevPageToken = nil
	} else if data, err := o.PrevPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PrevPageToken = &phantom_time_serie.PagerCursor{}
		if err := result.PrevPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.NextPageToken == nil {
		result.NextPageToken = nil
	} else if data, err := o.NextPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.NextPageToken = &phantom_time_serie.PagerCursor{}
		if err := result.NextPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

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

func (o *WatchPhantomTimeSeriesResponse_PageTokenChange) Merge(source *WatchPhantomTimeSeriesResponse_PageTokenChange) {
	if source.GetPrevPageToken() != nil {
		if data, err := source.GetPrevPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PrevPageToken = &phantom_time_serie.PagerCursor{}
			if err := o.PrevPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PrevPageToken = nil
	}
	if source.GetNextPageToken() != nil {
		if data, err := source.GetNextPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.NextPageToken = &phantom_time_serie.PagerCursor{}
			if err := o.NextPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.NextPageToken = nil
	}
}

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

func (o *CreatePhantomTimeSerieRequest) GotenObjectExt() {}

func (o *CreatePhantomTimeSerieRequest) MakeFullFieldMask() *CreatePhantomTimeSerieRequest_FieldMask {
	return FullCreatePhantomTimeSerieRequest_FieldMask()
}

func (o *CreatePhantomTimeSerieRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullCreatePhantomTimeSerieRequest_FieldMask()
}

func (o *CreatePhantomTimeSerieRequest) MakeDiffFieldMask(other *CreatePhantomTimeSerieRequest) *CreatePhantomTimeSerieRequest_FieldMask {
	if o == nil && other == nil {
		return &CreatePhantomTimeSerieRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullCreatePhantomTimeSerieRequest_FieldMask()
	}

	res := &CreatePhantomTimeSerieRequest_FieldMask{}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &CreatePhantomTimeSerieRequest_FieldTerminalPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorParent})
	}
	{
		subMask := o.GetPhantomTimeSerie().MakeDiffFieldMask(other.GetPhantomTimeSerie())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &CreatePhantomTimeSerieRequest_FieldTerminalPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &CreatePhantomTimeSerieRequest_FieldSubPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *CreatePhantomTimeSerieRequest) Clone() *CreatePhantomTimeSerieRequest {
	if o == nil {
		return nil
	}
	result := &CreatePhantomTimeSerieRequest{}
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &phantom_time_serie.ParentReference{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PhantomTimeSerie = o.PhantomTimeSerie.Clone()
	return result
}

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

func (o *CreatePhantomTimeSerieRequest) Merge(source *CreatePhantomTimeSerieRequest) {
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &phantom_time_serie.ParentReference{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	if source.GetPhantomTimeSerie() != nil {
		if o.PhantomTimeSerie == nil {
			o.PhantomTimeSerie = new(phantom_time_serie.PhantomTimeSerie)
		}
		o.PhantomTimeSerie.Merge(source.GetPhantomTimeSerie())
	}
}

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

func (o *UpdatePhantomTimeSerieRequest) GotenObjectExt() {}

func (o *UpdatePhantomTimeSerieRequest) MakeFullFieldMask() *UpdatePhantomTimeSerieRequest_FieldMask {
	return FullUpdatePhantomTimeSerieRequest_FieldMask()
}

func (o *UpdatePhantomTimeSerieRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullUpdatePhantomTimeSerieRequest_FieldMask()
}

func (o *UpdatePhantomTimeSerieRequest) MakeDiffFieldMask(other *UpdatePhantomTimeSerieRequest) *UpdatePhantomTimeSerieRequest_FieldMask {
	if o == nil && other == nil {
		return &UpdatePhantomTimeSerieRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullUpdatePhantomTimeSerieRequest_FieldMask()
	}

	res := &UpdatePhantomTimeSerieRequest_FieldMask{}
	{
		subMask := o.GetPhantomTimeSerie().MakeDiffFieldMask(other.GetPhantomTimeSerie())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequest_FieldSubPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetUpdateMask(), other.GetUpdateMask()) {
		res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask})
	}
	{
		subMask := o.GetCas().MakeDiffFieldMask(other.GetCas())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorCas})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequest_FieldSubPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorCas, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *UpdatePhantomTimeSerieRequest) Clone() *UpdatePhantomTimeSerieRequest {
	if o == nil {
		return nil
	}
	result := &UpdatePhantomTimeSerieRequest{}
	result.PhantomTimeSerie = o.PhantomTimeSerie.Clone()
	result.UpdateMask = proto.Clone(o.UpdateMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	result.Cas = o.Cas.Clone()
	return result
}

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

func (o *UpdatePhantomTimeSerieRequest) Merge(source *UpdatePhantomTimeSerieRequest) {
	if source.GetPhantomTimeSerie() != nil {
		if o.PhantomTimeSerie == nil {
			o.PhantomTimeSerie = new(phantom_time_serie.PhantomTimeSerie)
		}
		o.PhantomTimeSerie.Merge(source.GetPhantomTimeSerie())
	}
	if source.GetUpdateMask() != nil {
		if o.UpdateMask == nil {
			o.UpdateMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetUpdateMask().ToProtoFieldMask(), o.UpdateMask.ToProtoFieldMask())
		if err := o.UpdateMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	if source.GetCas() != nil {
		if o.Cas == nil {
			o.Cas = new(UpdatePhantomTimeSerieRequest_CAS)
		}
		o.Cas.Merge(source.GetCas())
	}
}

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

func (o *UpdatePhantomTimeSerieRequest_CAS) GotenObjectExt() {}

func (o *UpdatePhantomTimeSerieRequest_CAS) MakeFullFieldMask() *UpdatePhantomTimeSerieRequest_CAS_FieldMask {
	return FullUpdatePhantomTimeSerieRequest_CAS_FieldMask()
}

func (o *UpdatePhantomTimeSerieRequest_CAS) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullUpdatePhantomTimeSerieRequest_CAS_FieldMask()
}

func (o *UpdatePhantomTimeSerieRequest_CAS) MakeDiffFieldMask(other *UpdatePhantomTimeSerieRequest_CAS) *UpdatePhantomTimeSerieRequest_CAS_FieldMask {
	if o == nil && other == nil {
		return &UpdatePhantomTimeSerieRequest_CAS_FieldMask{}
	}
	if o == nil || other == nil {
		return FullUpdatePhantomTimeSerieRequest_CAS_FieldMask()
	}

	res := &UpdatePhantomTimeSerieRequest_CAS_FieldMask{}
	{
		subMask := o.GetConditionalState().MakeDiffFieldMask(other.GetConditionalState())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequestCAS_FieldSubPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask})
	}
	return res
}

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

func (o *UpdatePhantomTimeSerieRequest_CAS) Clone() *UpdatePhantomTimeSerieRequest_CAS {
	if o == nil {
		return nil
	}
	result := &UpdatePhantomTimeSerieRequest_CAS{}
	result.ConditionalState = o.ConditionalState.Clone()
	result.FieldMask = proto.Clone(o.FieldMask).(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return result
}

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

func (o *UpdatePhantomTimeSerieRequest_CAS) Merge(source *UpdatePhantomTimeSerieRequest_CAS) {
	if source.GetConditionalState() != nil {
		if o.ConditionalState == nil {
			o.ConditionalState = new(phantom_time_serie.PhantomTimeSerie)
		}
		o.ConditionalState.Merge(source.GetConditionalState())
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(phantom_time_serie.PhantomTimeSerie_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
}

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

func (o *DeletePhantomTimeSerieRequest) GotenObjectExt() {}

func (o *DeletePhantomTimeSerieRequest) MakeFullFieldMask() *DeletePhantomTimeSerieRequest_FieldMask {
	return FullDeletePhantomTimeSerieRequest_FieldMask()
}

func (o *DeletePhantomTimeSerieRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDeletePhantomTimeSerieRequest_FieldMask()
}

func (o *DeletePhantomTimeSerieRequest) MakeDiffFieldMask(other *DeletePhantomTimeSerieRequest) *DeletePhantomTimeSerieRequest_FieldMask {
	if o == nil && other == nil {
		return &DeletePhantomTimeSerieRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDeletePhantomTimeSerieRequest_FieldMask()
	}

	res := &DeletePhantomTimeSerieRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &DeletePhantomTimeSerieRequest_FieldTerminalPath{selector: DeletePhantomTimeSerieRequest_FieldPathSelectorName})
	}
	return res
}

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

func (o *DeletePhantomTimeSerieRequest) Clone() *DeletePhantomTimeSerieRequest {
	if o == nil {
		return nil
	}
	result := &DeletePhantomTimeSerieRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &phantom_time_serie.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

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

func (o *DeletePhantomTimeSerieRequest) Merge(source *DeletePhantomTimeSerieRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &phantom_time_serie.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
}

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