[chore] [pdata] Change CopyTo to operate directly on proto

pdata/internal/cmd/pdatagen/internal/base_fields.go

@@ -149,8 +149,12 @@ func Test{{ .structName }}_CopyTo_{{ .fieldName }}(t *testing.T) {
 	assert.Panics(t, func() { ms.CopyTo(new{{ .structName }}(&{{ .originStructName }}{}, &sharedState)) })
 }`
 
-const copyToValueOneOfMessageTemplate = `	case {{ .typeName }}:
-		ms.{{ .fieldName }}().CopyTo(dest.SetEmpty{{ .fieldName }}())`
+const copyToValueOneOfMessageTemplate = `	case *{{ .originStructType }}:
+		{{ .lowerFieldName }} := &{{ .originFieldPackageName}}.{{ .fieldName }}{}
+		copyOrig{{ .returnType }}({{ .lowerFieldName }}, t.{{ .fieldName }})
+		dest.{{ .originOneOfFieldName }} = &{{ .originStructType }}{
+			{{ .fieldName }}: {{ .lowerFieldName }},
+		}`
 
 const accessorsOneOfPrimitiveTemplate = `// {{ .accessorFieldName }} returns the {{ .lowerFieldName }} associated with this {{ .structName }}.
 func (ms {{ .structName }}) {{ .accessorFieldName }}() {{ .returnType }} {
@@ -286,7 +290,7 @@ type baseField interface {
 
 	GenerateSetWithTestValue(ms *messageValueStruct) string
 
-	GenerateCopyToValue(ms *messageValueStruct) string
+	GenerateCopyOrig(ms *messageValueStruct) string
 }
 
 type sliceField struct {
@@ -322,8 +326,15 @@ func (sf *sliceField) GenerateSetWithTestValue(ms *messageValueStruct) string {
 	return sb.String()
 }
 
-func (sf *sliceField) GenerateCopyToValue(*messageValueStruct) string {
-	return "\tms." + sf.fieldName + "().CopyTo(dest." + sf.fieldName + "())"
+func (sf *sliceField) GenerateCopyOrig(ms *messageValueStruct) string {
+	of := sf.origFieldName()
+	co := "copyOrig"
+	if usedByOtherDataTypes(ms.packageName) {
+		co = "CopyOrig"
+	} else if usedByOtherDataTypes(sf.returnSlice.getPackageName()) {
+		co = "internal.CopyOrig"
+	}
+	return "\tdest." + of + " = " + co + sf.returnSlice.getName() + "(dest." + of + ", src." + of + ")"
 }
 
 func (sf *sliceField) templateFields(ms *messageValueStruct) map[string]any {
@@ -341,15 +352,17 @@ func (sf *sliceField) templateFields(ms *messageValueStruct) map[string]any {
 		"stateAccessor":      stateAccessor(ms.packageName),
 		"isCommon":           usedByOtherDataTypes(sf.returnSlice.getPackageName()),
 		"isBaseStructCommon": usedByOtherDataTypes(ms.packageName),
-		"originFieldName": func() string {
-			if sf.originFieldName == "" {
-				return sf.fieldName
-			}
-			return sf.originFieldName
-		}(),
+		"originFieldName":    sf.origFieldName(),
 	}
 }
 
+func (sf *sliceField) origFieldName() string {
+	if sf.originFieldName == "" {
+		return sf.fieldName
+	}
+	return sf.originFieldName
+}
+
 var _ baseField = (*sliceField)(nil)
 
 type messageValueField struct {
@@ -384,8 +397,12 @@ func (mf *messageValueField) GenerateSetWithTestValue(ms *messageValueStruct) st
 	return sb.String()
 }
 
-func (mf *messageValueField) GenerateCopyToValue(*messageValueStruct) string {
-	return "\tms." + mf.fieldName + "().CopyTo(dest." + mf.fieldName + "())"
+func (mf *messageValueField) GenerateCopyOrig(*messageValueStruct) string {
+	co := "copyOrig"
+	if usedByOtherDataTypes(mf.returnMessage.packageName) {
+		co = "internal.CopyOrig"
+	}
+	return "\t" + co + mf.returnMessage.getName() + "(&dest." + mf.fieldName + ", &src." + mf.fieldName + ")"
 }
 
 func (mf *messageValueField) templateFields(ms *messageValueStruct) map[string]any {
@@ -443,8 +460,8 @@ func (pf *primitiveField) GenerateSetWithTestValue(*messageValueStruct) string {
 	return "\ttv.orig." + originFieldName + " = " + pf.testVal
 }
 
-func (pf *primitiveField) GenerateCopyToValue(*messageValueStruct) string {
-	return "\tdest.Set" + pf.fieldName + "(ms." + pf.fieldName + "())"
+func (pf *primitiveField) GenerateCopyOrig(*messageValueStruct) string {
+	return "\tdest." + pf.origFieldName() + " = src." + pf.origFieldName()
 }
 
 func (pf *primitiveField) templateFields(ms *messageValueStruct) map[string]any {
@@ -459,15 +476,17 @@ func (pf *primitiveField) templateFields(ms *messageValueStruct) map[string]any
 		"origAccessor":     origAccessor(ms.packageName),
 		"stateAccessor":    stateAccessor(ms.packageName),
 		"originStructName": ms.originFullName,
-		"originFieldName": func() string {
-			if pf.originFieldName == "" {
-				return pf.fieldName
-			}
-			return pf.originFieldName
-		}(),
+		"originFieldName":  pf.origFieldName(),
 	}
 }
 
+func (pf *primitiveField) origFieldName() string {
+	if pf.originFieldName == "" {
+		return pf.fieldName
+	}
+	return pf.originFieldName
+}
+
 var _ baseField = (*primitiveField)(nil)
 
 type primitiveType struct {
@@ -511,8 +530,8 @@ func (ptf *primitiveTypedField) GenerateSetWithTestValue(*messageValueStruct) st
 	return "\ttv.orig." + originFieldName + " = " + ptf.returnType.testVal
 }
 
-func (ptf *primitiveTypedField) GenerateCopyToValue(*messageValueStruct) string {
-	return "\tdest.Set" + ptf.fieldName + "(ms." + ptf.fieldName + "())"
+func (ptf *primitiveTypedField) GenerateCopyOrig(*messageValueStruct) string {
+	return "\tdest." + ptf.origFieldName() + " = src." + ptf.origFieldName()
 }
 
 func (ptf *primitiveTypedField) templateFields(ms *messageValueStruct) map[string]any {
@@ -525,20 +544,22 @@ func (ptf *primitiveTypedField) templateFields(ms *messageValueStruct) map[strin
 			}
 			return ""
 		}(),
-		"returnType":     ptf.returnType.structName,
-		"fieldName":      ptf.fieldName,
-		"lowerFieldName": strings.ToLower(ptf.fieldName),
-		"testValue":      ptf.returnType.testVal,
-		"rawType":        ptf.returnType.rawType,
-		"originFieldName": func() string {
-			if ptf.originFieldName == "" {
-				return ptf.fieldName
-			}
-			return ptf.originFieldName
-		}(),
+		"returnType":      ptf.returnType.structName,
+		"fieldName":       ptf.fieldName,
+		"lowerFieldName":  strings.ToLower(ptf.fieldName),
+		"testValue":       ptf.returnType.testVal,
+		"rawType":         ptf.returnType.rawType,
+		"originFieldName": ptf.origFieldName(),
 	}
 }
 
+func (ptf *primitiveTypedField) origFieldName() string {
+	if ptf.originFieldName == "" {
+		return ptf.fieldName
+	}
+	return ptf.originFieldName
+}
+
 var _ baseField = (*primitiveTypedField)(nil)
 
 // primitiveSliceField is used to generate fields for slice of primitive types
@@ -573,8 +594,14 @@ func (psf *primitiveSliceField) GenerateSetWithTestValue(*messageValueStruct) st
 	return "\ttv.orig." + psf.fieldName + " = " + psf.testVal
 }
 
-func (psf *primitiveSliceField) GenerateCopyToValue(*messageValueStruct) string {
-	return "\tms." + psf.fieldName + "().CopyTo(dest." + psf.fieldName + "())"
+func (psf *primitiveSliceField) GenerateCopyOrig(ms *messageValueStruct) string {
+	co := "copyOrig"
+	if usedByOtherDataTypes(ms.packageName) {
+		co = "CopyOrig"
+	} else if usedByOtherDataTypes(psf.returnPackageName) {
+		co = "internal.CopyOrig"
+	}
+	return "\tdest." + psf.fieldName + " = " + co + psf.returnType + "(dest." + psf.fieldName + ", " + "src." + psf.fieldName + ")"
 }
 
 func (psf *primitiveSliceField) templateFields(ms *messageValueStruct) map[string]any {
@@ -636,13 +663,13 @@ func (of *oneOfField) GenerateSetWithTestValue(ms *messageValueStruct) string {
 	return of.values[of.testValueIdx].GenerateSetWithTestValue(ms, of)
 }
 
-func (of *oneOfField) GenerateCopyToValue(ms *messageValueStruct) string {
+func (of *oneOfField) GenerateCopyOrig(ms *messageValueStruct) string {
 	sb := &bytes.Buffer{}
-	sb.WriteString("\tswitch ms." + of.typeFuncName() + "() {\n")
+	sb.WriteString("\tswitch t := src." + of.originFieldName + ".(type) {\n")
 	for _, v := range of.values {
-		v.GenerateCopyToValue(ms, of, sb)
+		v.GenerateCopyOrig(ms, of, sb)
 	}
-	sb.WriteString("\t}\n")
+	sb.WriteString("\t}")
 	return sb.String()
 }
 
@@ -668,7 +695,7 @@ type oneOfValue interface {
 	GenerateAccessors(ms *messageValueStruct, of *oneOfField) string
 	GenerateTests(ms *messageValueStruct, of *oneOfField) string
 	GenerateSetWithTestValue(ms *messageValueStruct, of *oneOfField) string
-	GenerateCopyToValue(ms *messageValueStruct, of *oneOfField, sb *bytes.Buffer)
+	GenerateCopyOrig(ms *messageValueStruct, of *oneOfField, sb *bytes.Buffer)
 	GenerateTypeSwitchCase(ms *messageValueStruct, of *oneOfField) string
 }
 
@@ -711,9 +738,9 @@ func (opv *oneOfPrimitiveValue) GenerateSetWithTestValue(ms *messageValueStruct,
 		originFieldName + ":" + opv.testVal + "}"
 }
 
-func (opv *oneOfPrimitiveValue) GenerateCopyToValue(_ *messageValueStruct, of *oneOfField, sb *bytes.Buffer) {
-	sb.WriteString("\tcase " + of.typeName + opv.fieldName + ":\n")
-	sb.WriteString("\tdest.Set" + opv.accessorFieldName(of) + "(ms." + opv.accessorFieldName(of) + "())\n")
+func (opv *oneOfPrimitiveValue) GenerateCopyOrig(ms *messageValueStruct, of *oneOfField, sb *bytes.Buffer) {
+	sb.WriteString("\tcase *" + ms.originFullName + "_" + opv.originFieldName + ":\n")
+	sb.WriteString("\tdest." + of.originFieldName + " = &" + ms.originFullName + "_" + opv.originFieldName + "{" + opv.originFieldName + ": t." + opv.originFieldName + "}\n")
 }
 
 func (opv *oneOfPrimitiveValue) GenerateTypeSwitchCase(ms *messageValueStruct, of *oneOfField) string {
@@ -772,7 +799,7 @@ func (omv *oneOfMessageValue) GenerateSetWithTestValue(ms *messageValueStruct, o
 		"\tfillTest" + omv.returnMessage.structName + "(new" + omv.fieldName + "(tv.orig.Get" + omv.fieldName + "(), tv.state))"
 }
 
-func (omv *oneOfMessageValue) GenerateCopyToValue(ms *messageValueStruct, of *oneOfField, sb *bytes.Buffer) {
+func (omv *oneOfMessageValue) GenerateCopyOrig(ms *messageValueStruct, of *oneOfField, sb *bytes.Buffer) {
 	t := template.Must(template.New("copyToValueOneOfMessageTemplate").Parse(copyToValueOneOfMessageTemplate))
 	if err := t.Execute(sb, omv.templateFields(ms, of)); err != nil {
 		panic(err)
@@ -832,10 +859,10 @@ func (opv *optionalPrimitiveValue) GenerateSetWithTestValue(ms *messageValueStru
 	return "\ttv.orig." + opv.fieldName + "_ = &" + ms.originFullName + "_" + opv.fieldName + "{" + opv.fieldName + ":" + opv.testVal + "}"
 }
 
-func (opv *optionalPrimitiveValue) GenerateCopyToValue(*messageValueStruct) string {
-	return "if ms.Has" + opv.fieldName + "(){\n" +
-		"\tdest.Set" + opv.fieldName + "(ms." + opv.fieldName + "())\n" +
-		"}\n"
+func (opv *optionalPrimitiveValue) GenerateCopyOrig(ms *messageValueStruct) string {
+	return "if src." + opv.fieldName + "_ != nil {\n" +
+		"\tdest." + opv.fieldName + "_ = &" + ms.originFullName + "_" + opv.fieldName + "{" + opv.fieldName + ": src.Get" + opv.fieldName + "()}\n" +
+		"}"
 }
 
 func (opv *optionalPrimitiveValue) templateFields(ms *messageValueStruct) map[string]any {

pdata/internal/cmd/pdatagen/internal/base_slices.go

@@ -53,6 +53,7 @@ func (ss *sliceOfPtrs) templateFields(packageInfo *PackageInfo) map[string]any {
 		"elementName":        ss.element.structName,
 		"originName":         ss.element.originFullName,
 		"originElementType":  "*" + ss.element.originFullName,
+		"originElementPtr":   "",
 		"emptyOriginElement": "&" + ss.element.originFullName + "{}",
 		"newElement":         "new" + ss.element.structName + "((*es." + orig + ")[i], es." + state + ")",
 		"origAccessor":       orig,
@@ -113,6 +114,7 @@ func (ss *sliceOfValues) templateFields(packageInfo *PackageInfo) map[string]any
 		"elementName":        ss.element.structName,
 		"originName":         ss.element.originFullName,
 		"originElementType":  ss.element.originFullName,
+		"originElementPtr":   "&",
 		"emptyOriginElement": ss.element.originFullName + "{}",
 		"newElement":         "new" + ss.element.structName + "(&(*es." + orig + ")[i], es." + state + ")",
 		"origAccessor":       orig,

pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl

@@ -75,7 +75,17 @@ func (ms {{ .structName }}) getState() *internal.State {
 // CopyTo copies all properties from the current struct overriding the destination.
 func (ms {{ .structName }}) CopyTo(dest {{ .structName }}) {
 	dest.{{ .stateAccessor }}.AssertMutable()
+    {{- if .isCommon }}
+    internal.CopyOrig{{ .structName }}(dest.{{ .origAccessor }}, ms.{{ .origAccessor }})
+    {{- else }}
+    copyOrig{{ .structName }}(dest.{{ .origAccessor }}, ms.{{ .origAccessor }})
+	{{- end }}
+}
+
+{{ if not .isCommon -}}
+func copyOrig{{ .structName }}(dest, src *{{ .originName }}) {
 	{{- range .fields }}
-	{{ .GenerateCopyToValue $.messageStruct }}
+	{{ .GenerateCopyOrig $.messageStruct }}
 	{{- end }}
 }
+{{- end }}

pdata/internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl

@@ -31,6 +31,12 @@ func New{{ .structName }}(orig *{{ .originName }}, state *State) {{ .structName
 	return {{ .structName }}{orig: orig, state: state}
 }
 
+func CopyOrig{{ .structName }}(dest, src *{{ .originName }}) {
+    {{- range .fields }}
+    {{ .GenerateCopyOrig $.messageStruct }}
+    {{- end }}
+}
+
 func GenerateTest{{ .structName }}() {{ .structName }} {
 	orig := {{ .originName }}{}
 	state := StateMutable

pdata/internal/cmd/pdatagen/internal/templates/primitive_slice.go.tmpl

@@ -36,13 +36,13 @@ func New{{ .structName }}() {{ .structName }} {
 
 // AsRaw returns a copy of the []{{ .itemType }} slice.
 func (ms {{ .structName }}) AsRaw() []{{ .itemType }} {
-	return copy{{ .structName }}(nil, *ms.getOrig())
+	return internal.CopyOrig{{ .structName }}(nil, *ms.getOrig())
 }
 
 // FromRaw copies raw []{{ .itemType }} into the slice {{ .structName }}.
 func (ms {{ .structName }}) FromRaw(val []{{ .itemType }}) {
 	ms.getState().AssertMutable()
-	*ms.getOrig() = copy{{ .structName }}(*ms.getOrig(), val)
+	*ms.getOrig() = internal.CopyOrig{{ .structName }}(*ms.getOrig(), val)
 }
 
 // Len returns length of the []{{ .itemType }} slice value.
@@ -130,15 +130,10 @@ func (ms {{ .structName }}) MoveAndAppendTo(dest {{ .structName }}) {
 // CopyTo copies all elements from the current slice overriding the destination.
 func (ms {{ .structName }}) CopyTo(dest {{ .structName }}) {
 	dest.getState().AssertMutable()
-	*dest.getOrig() = copy{{ .structName }}(*dest.getOrig(), *ms.getOrig())
+	*dest.getOrig() = internal.CopyOrig{{ .structName }}(*dest.getOrig(), *ms.getOrig())
 }
 
 // Equal checks equality with another {{ .structName }}
 func (ms {{ .structName }}) Equal(val {{ .structName }}) bool {
 	return slices.Equal(*ms.getOrig(), *val.getOrig())
 }
-
-func copy{{ .structName }}(dst, src []{{ .itemType }}) []{{ .itemType }} {
-	dst = dst[:0]
-	return append(dst, src...)
-}

pdata/internal/cmd/pdatagen/internal/templates/primitive_slice_internal.go.tmpl

@@ -31,6 +31,11 @@ func New{{ .structName }}(orig *[]{{ .itemType }}, state *State) {{ .structName
 	return {{ .structName }}{orig: orig, state: state}
 }
 
+func CopyOrig{{ .structName }}(dst, src []{{ .itemType }}) []{{ .itemType }} {
+	dst = dst[:0]
+	return append(dst, src...)
+}
+
 func FillTest{{ .structName }}(tv {{ .structName}}) {
 }
 

pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl

@@ -150,32 +150,10 @@ func (es {{ .structName }}) RemoveIf(f func({{ .elementName }}) bool) {
 // CopyTo copies all elements from the current slice overriding the destination.
 func (es {{ .structName }}) CopyTo(dest {{ .structName }}) {
 	dest.{{ .stateAccessor }}.AssertMutable()
-	srcLen := es.Len()
-	destCap := cap(*dest.{{ .origAccessor }})
-	if srcLen <= destCap {
-		(*dest.{{ .origAccessor }}) = (*dest.{{ .origAccessor }})[:srcLen:destCap]
-
-	{{- if eq .type "sliceOfPtrs" }}
-		for i := range *es.{{ .origAccessor }} {
-			new{{ .elementName }}((*es.{{ .origAccessor }})[i], es.{{ .stateAccessor }}).CopyTo(new{{ .elementName }}((*dest.{{ .origAccessor }})[i], dest.{{ .stateAccessor }}))
-		}
-		return
-	}
-	origs := make([]{{ .originName }}, srcLen)
-	wrappers := make([]*{{ .originName }}, srcLen)
-	for i := range *es.{{ .origAccessor }} {
-		wrappers[i] = &origs[i]
-		new{{ .elementName }}((*es.{{ .origAccessor }})[i], es.{{ .stateAccessor }}).CopyTo(new{{ .elementName }}(wrappers[i], dest.{{ .stateAccessor }}))
-	}
-	*dest.{{ .origAccessor }} = wrappers
-
+	{{- if .isCommon }}
+	*dest.{{ .origAccessor }} = internal.CopyOrig{{ .structName }}(*dest.{{ .origAccessor }}, *es.{{ .origAccessor }})
 	{{- else }}
-	} else {
-		(*dest.{{ .origAccessor }}) = make([]{{ .originElementType }}, srcLen)
-	}
-	for i := range *es.{{ .origAccessor }} {
-		{{ .newElement }}.CopyTo(new{{ .elementName }}(&(*dest.{{ .origAccessor }})[i], dest.{{ .stateAccessor }}))
-	}
+	*dest.{{ .origAccessor }} = copyOrig{{ .structName }}(*dest.{{ .origAccessor }}, *es.{{ .origAccessor }})
 	{{- end }}
 }
 
@@ -197,4 +175,22 @@ func (ms {{ .structName }}) getOrig() *[]{{ .originElementType }} {
 func (ms {{ .structName }}) getState() *internal.State {
 	return internal.Get{{ .structName }}State(internal.{{ .structName }}(ms))
 }
+{{- else }}
+
+func copyOrig{{ .structName }}(dest, src []{{ .originElementType }}) []{{ .originElementType }} {
+	if cap(dest) < len(src) {
+		dest = make([]{{ .originElementType }}, len(src))
+		{{- if eq .type "sliceOfPtrs" }}
+		data := make([]{{ .originName }}, len(src))
+		for i := range src {
+			dest[i] = &data[i]
+		}
+		{{- end }}
+	}
+	dest = dest[:len(src)]
+	for i := range src {
+		copyOrig{{ .elementName }}({{ .originElementPtr }}dest[i], {{ .originElementPtr }}src[i])
+	}
+	return dest
+}
 {{- end }}