activity_log.pb.object_ext.go

// Code generated by protoc-gen-goten-object
// File: edgelq/audit/proto/v1alpha2/activity_log.proto
// DO NOT EDIT!!!

package activity_log

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 (
	common "github.com/cloudwan/edgelq-sdk/audit/resources/v1alpha2/common"
	rpc "github.com/cloudwan/edgelq-sdk/common/rpc"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	anypb "google.golang.org/protobuf/types/known/anypb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	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 (
	_ = &common.Authentication{}
	_ = &rpc.Status{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &anypb.Any{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
)

func (o *ActivityLog) GotenObjectExt() {}

func (o *ActivityLog) MakeFullFieldMask() *ActivityLog_FieldMask {
	return FullActivityLog_FieldMask()
}

func (o *ActivityLog) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_FieldMask()
}

func (o *ActivityLog) MakeDiffFieldMask(other *ActivityLog) *ActivityLog_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_FieldMask()
	}

	res := &ActivityLog_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorName})
	}
	if o.GetScope() != other.GetScope() {
		res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorScope})
	}
	if o.GetRequestId() != other.GetRequestId() {
		res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestId})
	}
	{
		subMask := o.GetAuthentication().MakeDiffFieldMask(other.GetAuthentication())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorAuthentication})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorAuthentication, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAuthorization().MakeDiffFieldMask(other.GetAuthorization())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorAuthorization})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorAuthorization, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetService().MakeDiffFieldMask(other.GetService())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorService})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorService, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetMethod().MakeDiffFieldMask(other.GetMethod())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorMethod})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorMethod, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetRequestMetadata().MakeDiffFieldMask(other.GetRequestMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorRequestMetadata, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetRequestRouting().MakeDiffFieldMask(other.GetRequestRouting())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestRouting})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorRequestRouting, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetResource().MakeDiffFieldMask(other.GetResource())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorResource})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorResource, subPath: subpath})
			}
		}
	}
	if o.GetCategory() != other.GetCategory() {
		res.Paths = append(res.Paths, &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorCategory})
	}

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

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

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

func (o *ActivityLog) Clone() *ActivityLog {
	if o == nil {
		return nil
	}
	result := &ActivityLog{}
	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.Scope = o.Scope
	result.RequestId = o.RequestId
	result.Authentication = o.Authentication.Clone()
	result.Authorization = o.Authorization.Clone()
	result.Service = o.Service.Clone()
	result.Method = o.Method.Clone()
	result.RequestMetadata = o.RequestMetadata.Clone()
	result.RequestRouting = o.RequestRouting.Clone()
	result.Resource = o.Resource.Clone()
	result.Category = o.Category
	result.Labels = map[string]string{}
	for key, sourceValue := range o.Labels {
		result.Labels[key] = sourceValue
	}
	result.Events = make([]*ActivityLog_Event, len(o.Events))
	for i, sourceValue := range o.Events {
		result.Events[i] = sourceValue.Clone()
	}
	return result
}

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

func (o *ActivityLog) Merge(source *ActivityLog) {
	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
	}
	o.Scope = source.GetScope()
	o.RequestId = source.GetRequestId()
	if source.GetAuthentication() != nil {
		if o.Authentication == nil {
			o.Authentication = new(common.Authentication)
		}
		o.Authentication.Merge(source.GetAuthentication())
	}
	if source.GetAuthorization() != nil {
		if o.Authorization == nil {
			o.Authorization = new(common.Authorization)
		}
		o.Authorization.Merge(source.GetAuthorization())
	}
	if source.GetService() != nil {
		if o.Service == nil {
			o.Service = new(common.ServiceData)
		}
		o.Service.Merge(source.GetService())
	}
	if source.GetMethod() != nil {
		if o.Method == nil {
			o.Method = new(ActivityLog_Method)
		}
		o.Method.Merge(source.GetMethod())
	}
	if source.GetRequestMetadata() != nil {
		if o.RequestMetadata == nil {
			o.RequestMetadata = new(ActivityLog_RequestMetadata)
		}
		o.RequestMetadata.Merge(source.GetRequestMetadata())
	}
	if source.GetRequestRouting() != nil {
		if o.RequestRouting == nil {
			o.RequestRouting = new(ActivityLog_RequestRouting)
		}
		o.RequestRouting.Merge(source.GetRequestRouting())
	}
	if source.GetResource() != nil {
		if o.Resource == nil {
			o.Resource = new(ActivityLog_Resource)
		}
		o.Resource.Merge(source.GetResource())
	}
	o.Category = source.GetCategory()
	if source.GetLabels() != nil {
		if o.Labels == nil {
			o.Labels = make(map[string]string, len(source.GetLabels()))
		}
		for key, sourceValue := range source.GetLabels() {
			o.Labels[key] = sourceValue
		}
	}
	for _, sourceValue := range source.GetEvents() {
		exists := false
		for _, currentValue := range o.Events {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *ActivityLog_Event
			if sourceValue != nil {
				newDstElement = new(ActivityLog_Event)
				newDstElement.Merge(sourceValue)
			}
			o.Events = append(o.Events, newDstElement)
		}
	}

}

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

func (o *ActivityLog_Event) GotenObjectExt() {}

func (o *ActivityLog_Event) MakeFullFieldMask() *ActivityLog_Event_FieldMask {
	return FullActivityLog_Event_FieldMask()
}

func (o *ActivityLog_Event) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_FieldMask()
}

func (o *ActivityLog_Event) MakeDiffFieldMask(other *ActivityLog_Event) *ActivityLog_Event_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_FieldMask()
	}

	res := &ActivityLog_Event_FieldMask{}
	{
		subMask := o.GetClientMessage().MakeDiffFieldMask(other.GetClientMessage())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorClientMessage})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorClientMessage, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetServerMessage().MakeDiffFieldMask(other.GetServerMessage())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorServerMessage})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorServerMessage, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetExit().MakeDiffFieldMask(other.GetExit())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorExit})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorExit, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetRegionalServerMessage().MakeDiffFieldMask(other.GetRegionalServerMessage())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorRegionalServerMessage})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorRegionalServerMessage, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetRegionalExit().MakeDiffFieldMask(other.GetRegionalExit())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorRegionalExit})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorRegionalExit, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *ActivityLog_Event) Clone() *ActivityLog_Event {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event{}
	if o, ok := o.Evt.(*ActivityLog_Event_ClientMessage); ok {
		result.Evt = (*ActivityLog_Event_ClientMessage)(nil)
		if o != nil {
			result.Evt = &ActivityLog_Event_ClientMessage{}
			result := result.Evt.(*ActivityLog_Event_ClientMessage)
			result.ClientMessage = o.ClientMessage.Clone()
		}
	}
	if o, ok := o.Evt.(*ActivityLog_Event_ServerMessage); ok {
		result.Evt = (*ActivityLog_Event_ServerMessage)(nil)
		if o != nil {
			result.Evt = &ActivityLog_Event_ServerMessage{}
			result := result.Evt.(*ActivityLog_Event_ServerMessage)
			result.ServerMessage = o.ServerMessage.Clone()
		}
	}
	if o, ok := o.Evt.(*ActivityLog_Event_Exit); ok {
		result.Evt = (*ActivityLog_Event_Exit)(nil)
		if o != nil {
			result.Evt = &ActivityLog_Event_Exit{}
			result := result.Evt.(*ActivityLog_Event_Exit)
			result.Exit = o.Exit.Clone()
		}
	}
	if o, ok := o.Evt.(*ActivityLog_Event_RegionalServerMessage); ok {
		result.Evt = (*ActivityLog_Event_RegionalServerMessage)(nil)
		if o != nil {
			result.Evt = &ActivityLog_Event_RegionalServerMessage{}
			result := result.Evt.(*ActivityLog_Event_RegionalServerMessage)
			result.RegionalServerMessage = o.RegionalServerMessage.Clone()
		}
	}
	if o, ok := o.Evt.(*ActivityLog_Event_RegionalExit); ok {
		result.Evt = (*ActivityLog_Event_RegionalExit)(nil)
		if o != nil {
			result.Evt = &ActivityLog_Event_RegionalExit{}
			result := result.Evt.(*ActivityLog_Event_RegionalExit)
			result.RegionalExit = o.RegionalExit.Clone()
		}
	}
	return result
}

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

func (o *ActivityLog_Event) Merge(source *ActivityLog_Event) {
	if source, ok := source.GetEvt().(*ActivityLog_Event_ClientMessage); ok {
		if dstOneOf, ok := o.Evt.(*ActivityLog_Event_ClientMessage); !ok || dstOneOf == nil {
			o.Evt = &ActivityLog_Event_ClientMessage{}
		}
		if source != nil {
			o := o.Evt.(*ActivityLog_Event_ClientMessage)
			if source.ClientMessage != nil {
				if o.ClientMessage == nil {
					o.ClientMessage = new(ActivityLog_Event_ClientMsgEvent)
				}
				o.ClientMessage.Merge(source.ClientMessage)
			}
		}
	}
	if source, ok := source.GetEvt().(*ActivityLog_Event_ServerMessage); ok {
		if dstOneOf, ok := o.Evt.(*ActivityLog_Event_ServerMessage); !ok || dstOneOf == nil {
			o.Evt = &ActivityLog_Event_ServerMessage{}
		}
		if source != nil {
			o := o.Evt.(*ActivityLog_Event_ServerMessage)
			if source.ServerMessage != nil {
				if o.ServerMessage == nil {
					o.ServerMessage = new(ActivityLog_Event_ServerMsgEvent)
				}
				o.ServerMessage.Merge(source.ServerMessage)
			}
		}
	}
	if source, ok := source.GetEvt().(*ActivityLog_Event_Exit); ok {
		if dstOneOf, ok := o.Evt.(*ActivityLog_Event_Exit); !ok || dstOneOf == nil {
			o.Evt = &ActivityLog_Event_Exit{}
		}
		if source != nil {
			o := o.Evt.(*ActivityLog_Event_Exit)
			if source.Exit != nil {
				if o.Exit == nil {
					o.Exit = new(ActivityLog_Event_ExitEvent)
				}
				o.Exit.Merge(source.Exit)
			}
		}
	}
	if source, ok := source.GetEvt().(*ActivityLog_Event_RegionalServerMessage); ok {
		if dstOneOf, ok := o.Evt.(*ActivityLog_Event_RegionalServerMessage); !ok || dstOneOf == nil {
			o.Evt = &ActivityLog_Event_RegionalServerMessage{}
		}
		if source != nil {
			o := o.Evt.(*ActivityLog_Event_RegionalServerMessage)
			if source.RegionalServerMessage != nil {
				if o.RegionalServerMessage == nil {
					o.RegionalServerMessage = new(ActivityLog_Event_RegionalServerMsgEvent)
				}
				o.RegionalServerMessage.Merge(source.RegionalServerMessage)
			}
		}
	}
	if source, ok := source.GetEvt().(*ActivityLog_Event_RegionalExit); ok {
		if dstOneOf, ok := o.Evt.(*ActivityLog_Event_RegionalExit); !ok || dstOneOf == nil {
			o.Evt = &ActivityLog_Event_RegionalExit{}
		}
		if source != nil {
			o := o.Evt.(*ActivityLog_Event_RegionalExit)
			if source.RegionalExit != nil {
				if o.RegionalExit == nil {
					o.RegionalExit = new(ActivityLog_Event_RegionalServerMsgEvent)
				}
				o.RegionalExit.Merge(source.RegionalExit)
			}
		}
	}
}

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

func (o *ActivityLog_Method) GotenObjectExt() {}

func (o *ActivityLog_Method) MakeFullFieldMask() *ActivityLog_Method_FieldMask {
	return FullActivityLog_Method_FieldMask()
}

func (o *ActivityLog_Method) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Method_FieldMask()
}

func (o *ActivityLog_Method) MakeDiffFieldMask(other *ActivityLog_Method) *ActivityLog_Method_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Method_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Method_FieldMask()
	}

	res := &ActivityLog_Method_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &ActivityLogMethod_FieldTerminalPath{selector: ActivityLogMethod_FieldPathSelectorType})
	}
	if o.GetVersion() != other.GetVersion() {
		res.Paths = append(res.Paths, &ActivityLogMethod_FieldTerminalPath{selector: ActivityLogMethod_FieldPathSelectorVersion})
	}
	return res
}

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

func (o *ActivityLog_Method) Clone() *ActivityLog_Method {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Method{}
	result.Type = o.Type
	result.Version = o.Version
	return result
}

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

func (o *ActivityLog_Method) Merge(source *ActivityLog_Method) {
	o.Type = source.GetType()
	o.Version = source.GetVersion()
}

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

func (o *ActivityLog_RequestMetadata) GotenObjectExt() {}

func (o *ActivityLog_RequestMetadata) MakeFullFieldMask() *ActivityLog_RequestMetadata_FieldMask {
	return FullActivityLog_RequestMetadata_FieldMask()
}

func (o *ActivityLog_RequestMetadata) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_RequestMetadata_FieldMask()
}

func (o *ActivityLog_RequestMetadata) MakeDiffFieldMask(other *ActivityLog_RequestMetadata) *ActivityLog_RequestMetadata_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_RequestMetadata_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_RequestMetadata_FieldMask()
	}

	res := &ActivityLog_RequestMetadata_FieldMask{}
	if o.GetIpAddress() != other.GetIpAddress() {
		res.Paths = append(res.Paths, &ActivityLogRequestMetadata_FieldTerminalPath{selector: ActivityLogRequestMetadata_FieldPathSelectorIpAddress})
	}
	if o.GetUserAgent() != other.GetUserAgent() {
		res.Paths = append(res.Paths, &ActivityLogRequestMetadata_FieldTerminalPath{selector: ActivityLogRequestMetadata_FieldPathSelectorUserAgent})
	}
	return res
}

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

func (o *ActivityLog_RequestMetadata) Clone() *ActivityLog_RequestMetadata {
	if o == nil {
		return nil
	}
	result := &ActivityLog_RequestMetadata{}
	result.IpAddress = o.IpAddress
	result.UserAgent = o.UserAgent
	return result
}

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

func (o *ActivityLog_RequestMetadata) Merge(source *ActivityLog_RequestMetadata) {
	o.IpAddress = source.GetIpAddress()
	o.UserAgent = source.GetUserAgent()
}

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

func (o *ActivityLog_RequestRouting) GotenObjectExt() {}

func (o *ActivityLog_RequestRouting) MakeFullFieldMask() *ActivityLog_RequestRouting_FieldMask {
	return FullActivityLog_RequestRouting_FieldMask()
}

func (o *ActivityLog_RequestRouting) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_RequestRouting_FieldMask()
}

func (o *ActivityLog_RequestRouting) MakeDiffFieldMask(other *ActivityLog_RequestRouting) *ActivityLog_RequestRouting_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_RequestRouting_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_RequestRouting_FieldMask()
	}

	res := &ActivityLog_RequestRouting_FieldMask{}
	if o.GetViaRegion() != other.GetViaRegion() {
		res.Paths = append(res.Paths, &ActivityLogRequestRouting_FieldTerminalPath{selector: ActivityLogRequestRouting_FieldPathSelectorViaRegion})
	}

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

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

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

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

func (o *ActivityLog_RequestRouting) Merge(source *ActivityLog_RequestRouting) {
	o.ViaRegion = source.GetViaRegion()
	for _, sourceValue := range source.GetDestRegions() {
		exists := false
		for _, currentValue := range o.DestRegions {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.DestRegions = append(o.DestRegions, newDstElement)
		}
	}

}

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

func (o *ActivityLog_Resource) GotenObjectExt() {}

func (o *ActivityLog_Resource) MakeFullFieldMask() *ActivityLog_Resource_FieldMask {
	return FullActivityLog_Resource_FieldMask()
}

func (o *ActivityLog_Resource) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Resource_FieldMask()
}

func (o *ActivityLog_Resource) MakeDiffFieldMask(other *ActivityLog_Resource) *ActivityLog_Resource_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Resource_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Resource_FieldMask()
	}

	res := &ActivityLog_Resource_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &ActivityLogResource_FieldTerminalPath{selector: ActivityLogResource_FieldPathSelectorName})
	}
	{
		subMask := o.GetDifference().MakeDiffFieldMask(other.GetDifference())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogResource_FieldTerminalPath{selector: ActivityLogResource_FieldPathSelectorDifference})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogResource_FieldSubPath{selector: ActivityLogResource_FieldPathSelectorDifference, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *ActivityLog_Resource) Clone() *ActivityLog_Resource {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Resource{}
	result.Name = o.Name
	result.Difference = o.Difference.Clone()
	return result
}

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

func (o *ActivityLog_Resource) Merge(source *ActivityLog_Resource) {
	o.Name = source.GetName()
	if source.GetDifference() != nil {
		if o.Difference == nil {
			o.Difference = new(ActivityLog_Resource_Difference)
		}
		o.Difference.Merge(source.GetDifference())
	}
}

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

func (o *ActivityLog_Event_ClientMsgEvent) GotenObjectExt() {}

func (o *ActivityLog_Event_ClientMsgEvent) MakeFullFieldMask() *ActivityLog_Event_ClientMsgEvent_FieldMask {
	return FullActivityLog_Event_ClientMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_ClientMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_ClientMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_ClientMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_ClientMsgEvent) *ActivityLog_Event_ClientMsgEvent_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_ClientMsgEvent_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_ClientMsgEvent_FieldMask()
	}

	res := &ActivityLog_Event_ClientMsgEvent_FieldMask{}
	if !proto.Equal(o.GetData(), other.GetData()) {
		res.Paths = append(res.Paths, &ActivityLogEventClientMsgEvent_FieldTerminalPath{selector: ActivityLogEventClientMsgEvent_FieldPathSelectorData})
	}
	if !proto.Equal(o.GetTime(), other.GetTime()) {
		res.Paths = append(res.Paths, &ActivityLogEventClientMsgEvent_FieldTerminalPath{selector: ActivityLogEventClientMsgEvent_FieldPathSelectorTime})
	}
	return res
}

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

func (o *ActivityLog_Event_ClientMsgEvent) Clone() *ActivityLog_Event_ClientMsgEvent {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event_ClientMsgEvent{}
	result.Data = proto.Clone(o.Data).(*anypb.Any)
	result.Time = proto.Clone(o.Time).(*timestamppb.Timestamp)
	return result
}

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

func (o *ActivityLog_Event_ClientMsgEvent) Merge(source *ActivityLog_Event_ClientMsgEvent) {
	if source.GetData() != nil {
		if o.Data == nil {
			o.Data = new(anypb.Any)
		}
		proto.Merge(o.Data, source.GetData())
	}
	if source.GetTime() != nil {
		if o.Time == nil {
			o.Time = new(timestamppb.Timestamp)
		}
		proto.Merge(o.Time, source.GetTime())
	}
}

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

func (o *ActivityLog_Event_RegionalServerMsgEvent) GotenObjectExt() {}

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeFullFieldMask() *ActivityLog_Event_RegionalServerMsgEvent_FieldMask {
	return FullActivityLog_Event_RegionalServerMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_RegionalServerMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_Event_RegionalServerMsgEvent_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_RegionalServerMsgEvent_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_RegionalServerMsgEvent_FieldMask()
	}

	res := &ActivityLog_Event_RegionalServerMsgEvent_FieldMask{}
	if !proto.Equal(o.GetData(), other.GetData()) {
		res.Paths = append(res.Paths, &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData})
	}
	if !proto.Equal(o.GetTime(), other.GetTime()) {
		res.Paths = append(res.Paths, &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime})
	}
	if o.GetRegionId() != other.GetRegionId() {
		res.Paths = append(res.Paths, &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId})
	}
	return res
}

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

func (o *ActivityLog_Event_RegionalServerMsgEvent) Clone() *ActivityLog_Event_RegionalServerMsgEvent {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event_RegionalServerMsgEvent{}
	result.Data = proto.Clone(o.Data).(*anypb.Any)
	result.Time = proto.Clone(o.Time).(*timestamppb.Timestamp)
	result.RegionId = o.RegionId
	return result
}

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

func (o *ActivityLog_Event_RegionalServerMsgEvent) Merge(source *ActivityLog_Event_RegionalServerMsgEvent) {
	if source.GetData() != nil {
		if o.Data == nil {
			o.Data = new(anypb.Any)
		}
		proto.Merge(o.Data, source.GetData())
	}
	if source.GetTime() != nil {
		if o.Time == nil {
			o.Time = new(timestamppb.Timestamp)
		}
		proto.Merge(o.Time, source.GetTime())
	}
	o.RegionId = source.GetRegionId()
}

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

func (o *ActivityLog_Event_ServerMsgEvent) GotenObjectExt() {}

func (o *ActivityLog_Event_ServerMsgEvent) MakeFullFieldMask() *ActivityLog_Event_ServerMsgEvent_FieldMask {
	return FullActivityLog_Event_ServerMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_ServerMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_ServerMsgEvent_FieldMask()
}

func (o *ActivityLog_Event_ServerMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_ServerMsgEvent) *ActivityLog_Event_ServerMsgEvent_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_ServerMsgEvent_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_ServerMsgEvent_FieldMask()
	}

	res := &ActivityLog_Event_ServerMsgEvent_FieldMask{}
	if !proto.Equal(o.GetData(), other.GetData()) {
		res.Paths = append(res.Paths, &ActivityLogEventServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventServerMsgEvent_FieldPathSelectorData})
	}
	if !proto.Equal(o.GetTime(), other.GetTime()) {
		res.Paths = append(res.Paths, &ActivityLogEventServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventServerMsgEvent_FieldPathSelectorTime})
	}
	return res
}

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

func (o *ActivityLog_Event_ServerMsgEvent) Clone() *ActivityLog_Event_ServerMsgEvent {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event_ServerMsgEvent{}
	result.Data = proto.Clone(o.Data).(*anypb.Any)
	result.Time = proto.Clone(o.Time).(*timestamppb.Timestamp)
	return result
}

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

func (o *ActivityLog_Event_ServerMsgEvent) Merge(source *ActivityLog_Event_ServerMsgEvent) {
	if source.GetData() != nil {
		if o.Data == nil {
			o.Data = new(anypb.Any)
		}
		proto.Merge(o.Data, source.GetData())
	}
	if source.GetTime() != nil {
		if o.Time == nil {
			o.Time = new(timestamppb.Timestamp)
		}
		proto.Merge(o.Time, source.GetTime())
	}
}

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

func (o *ActivityLog_Event_RegionalExitEvent) GotenObjectExt() {}

func (o *ActivityLog_Event_RegionalExitEvent) MakeFullFieldMask() *ActivityLog_Event_RegionalExitEvent_FieldMask {
	return FullActivityLog_Event_RegionalExitEvent_FieldMask()
}

func (o *ActivityLog_Event_RegionalExitEvent) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_RegionalExitEvent_FieldMask()
}

func (o *ActivityLog_Event_RegionalExitEvent) MakeDiffFieldMask(other *ActivityLog_Event_RegionalExitEvent) *ActivityLog_Event_RegionalExitEvent_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_RegionalExitEvent_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_RegionalExitEvent_FieldMask()
	}

	res := &ActivityLog_Event_RegionalExitEvent_FieldMask{}
	{
		subMask := o.GetStatus().MakeDiffFieldMask(other.GetStatus())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEventRegionalExitEvent_FieldSubPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetTime(), other.GetTime()) {
		res.Paths = append(res.Paths, &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorTime})
	}
	if o.GetRegionId() != other.GetRegionId() {
		res.Paths = append(res.Paths, &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId})
	}
	return res
}

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

func (o *ActivityLog_Event_RegionalExitEvent) Clone() *ActivityLog_Event_RegionalExitEvent {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event_RegionalExitEvent{}
	result.Status = o.Status.Clone()
	result.Time = proto.Clone(o.Time).(*timestamppb.Timestamp)
	result.RegionId = o.RegionId
	return result
}

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

func (o *ActivityLog_Event_RegionalExitEvent) Merge(source *ActivityLog_Event_RegionalExitEvent) {
	if source.GetStatus() != nil {
		if o.Status == nil {
			o.Status = new(rpc.Status)
		}
		o.Status.Merge(source.GetStatus())
	}
	if source.GetTime() != nil {
		if o.Time == nil {
			o.Time = new(timestamppb.Timestamp)
		}
		proto.Merge(o.Time, source.GetTime())
	}
	o.RegionId = source.GetRegionId()
}

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

func (o *ActivityLog_Event_ExitEvent) GotenObjectExt() {}

func (o *ActivityLog_Event_ExitEvent) MakeFullFieldMask() *ActivityLog_Event_ExitEvent_FieldMask {
	return FullActivityLog_Event_ExitEvent_FieldMask()
}

func (o *ActivityLog_Event_ExitEvent) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Event_ExitEvent_FieldMask()
}

func (o *ActivityLog_Event_ExitEvent) MakeDiffFieldMask(other *ActivityLog_Event_ExitEvent) *ActivityLog_Event_ExitEvent_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Event_ExitEvent_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Event_ExitEvent_FieldMask()
	}

	res := &ActivityLog_Event_ExitEvent_FieldMask{}
	{
		subMask := o.GetStatus().MakeDiffFieldMask(other.GetStatus())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &ActivityLogEventExitEvent_FieldTerminalPath{selector: ActivityLogEventExitEvent_FieldPathSelectorStatus})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &ActivityLogEventExitEvent_FieldSubPath{selector: ActivityLogEventExitEvent_FieldPathSelectorStatus, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetTime(), other.GetTime()) {
		res.Paths = append(res.Paths, &ActivityLogEventExitEvent_FieldTerminalPath{selector: ActivityLogEventExitEvent_FieldPathSelectorTime})
	}
	return res
}

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

func (o *ActivityLog_Event_ExitEvent) Clone() *ActivityLog_Event_ExitEvent {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Event_ExitEvent{}
	result.Status = o.Status.Clone()
	result.Time = proto.Clone(o.Time).(*timestamppb.Timestamp)
	return result
}

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

func (o *ActivityLog_Event_ExitEvent) Merge(source *ActivityLog_Event_ExitEvent) {
	if source.GetStatus() != nil {
		if o.Status == nil {
			o.Status = new(rpc.Status)
		}
		o.Status.Merge(source.GetStatus())
	}
	if source.GetTime() != nil {
		if o.Time == nil {
			o.Time = new(timestamppb.Timestamp)
		}
		proto.Merge(o.Time, source.GetTime())
	}
}

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

func (o *ActivityLog_Resource_Difference) GotenObjectExt() {}

func (o *ActivityLog_Resource_Difference) MakeFullFieldMask() *ActivityLog_Resource_Difference_FieldMask {
	return FullActivityLog_Resource_Difference_FieldMask()
}

func (o *ActivityLog_Resource_Difference) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullActivityLog_Resource_Difference_FieldMask()
}

func (o *ActivityLog_Resource_Difference) MakeDiffFieldMask(other *ActivityLog_Resource_Difference) *ActivityLog_Resource_Difference_FieldMask {
	if o == nil && other == nil {
		return &ActivityLog_Resource_Difference_FieldMask{}
	}
	if o == nil || other == nil {
		return FullActivityLog_Resource_Difference_FieldMask()
	}

	res := &ActivityLog_Resource_Difference_FieldMask{}
	if !proto.Equal(o.GetFields(), other.GetFields()) {
		res.Paths = append(res.Paths, &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorFields})
	}
	if !proto.Equal(o.GetBefore(), other.GetBefore()) {
		res.Paths = append(res.Paths, &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorBefore})
	}
	if !proto.Equal(o.GetAfter(), other.GetAfter()) {
		res.Paths = append(res.Paths, &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorAfter})
	}
	return res
}

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

func (o *ActivityLog_Resource_Difference) Clone() *ActivityLog_Resource_Difference {
	if o == nil {
		return nil
	}
	result := &ActivityLog_Resource_Difference{}
	result.Fields = proto.Clone(o.Fields).(*fieldmaskpb.FieldMask)
	result.Before = proto.Clone(o.Before).(*anypb.Any)
	result.After = proto.Clone(o.After).(*anypb.Any)
	return result
}

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

func (o *ActivityLog_Resource_Difference) Merge(source *ActivityLog_Resource_Difference) {
	if source.GetFields() != nil {
		if o.Fields == nil {
			o.Fields = new(fieldmaskpb.FieldMask)
		}
		proto.Merge(o.Fields, source.GetFields())
	}
	if source.GetBefore() != nil {
		if o.Before == nil {
			o.Before = new(anypb.Any)
		}
		proto.Merge(o.Before, source.GetBefore())
	}
	if source.GetAfter() != nil {
		if o.After == nil {
			o.After = new(anypb.Any)
		}
		proto.Merge(o.After, source.GetAfter())
	}
}

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