[chore] Apply improvements and fixes for RemoveIf and CopyOrig to manually writen structs

pdata/internal/wrapper_map.go

@@ -26,15 +26,22 @@ func NewMap(orig *[]otlpcommon.KeyValue, state *State) Map {
 }
 
 func CopyOrigMap(dest, src []otlpcommon.KeyValue) []otlpcommon.KeyValue {
+	var newDest []otlpcommon.KeyValue
 	if cap(dest) < len(src) {
-		dest = make([]otlpcommon.KeyValue, len(src))
+		newDest = make([]otlpcommon.KeyValue, len(src))
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = otlpcommon.KeyValue{}
+		}
 	}
-	dest = dest[:len(src)]
-	for i := 0; i < len(src); i++ {
-		dest[i].Key = src[i].Key
-		CopyOrigValue(&dest[i].Value, &src[i].Value)
+	for i := range src {
+		newDest[i].Key = src[i].Key
+		CopyOrigValue(&newDest[i].Value, &src[i].Value)
 	}
-	return dest
+	return newDest
 }
 
 func GenerateTestMap() Map {

pdata/internal/wrapper_slice.go

@@ -26,14 +26,21 @@ func NewSlice(orig *[]otlpcommon.AnyValue, state *State) Slice {
 }
 
 func CopyOrigSlice(dest, src []otlpcommon.AnyValue) []otlpcommon.AnyValue {
+	var newDest []otlpcommon.AnyValue
 	if cap(dest) < len(src) {
-		dest = make([]otlpcommon.AnyValue, len(src))
+		newDest = make([]otlpcommon.AnyValue, len(src))
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = otlpcommon.AnyValue{}
+		}
 	}
-	dest = dest[:len(src)]
-	for i := 0; i < len(src); i++ {
-		CopyOrigValue(&dest[i], &src[i])
+	for i := range src {
+		CopyOrigValue(&newDest[i], &src[i])
 	}
-	return dest
+	return newDest
 }
 
 func GenerateTestSlice() Slice {

pdata/pcommon/map.go

@@ -94,8 +94,8 @@ func (m Map) RemoveIf(f func(string, Value) bool) {
 	m.getState().AssertMutable()
 	newLen := 0
 	for i := 0; i < len(*m.getOrig()); i++ {
-		akv := &(*m.getOrig())[i]
-		if f(akv.Key, newValue(&akv.Value, m.getState())) {
+		if f((*m.getOrig())[i].Key, newValue(&(*m.getOrig())[i].Value, m.getState())) {
+			(*m.getOrig())[i] = otlpcommon.KeyValue{}
 			continue
 		}
 		if newLen == i {
@@ -104,6 +104,7 @@ func (m Map) RemoveIf(f func(string, Value) bool) {
 			continue
 		}
 		(*m.getOrig())[newLen] = (*m.getOrig())[i]
+		(*m.getOrig())[i] = otlpcommon.KeyValue{}
 		newLen++
 	}
 	*m.getOrig() = (*m.getOrig())[:newLen]

pdata/pcommon/map_test.go

@@ -443,6 +443,14 @@ func TestMap_CopyTo(t *testing.T) {
 	assert.Equal(t, Map(internal.GenerateTestMap()), dest)
 }
 
+func TestMap_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewMap()
+	src := Map(internal.GenerateTestMap())
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
+	assert.Equal(t, Map(internal.GenerateTestMap()), dest)
+}
+
 func TestMap_EnsureCapacity_Zero(t *testing.T) {
 	am := NewMap()
 	am.EnsureCapacity(0)
@@ -532,6 +540,15 @@ func TestMap_RemoveIf(t *testing.T) {
 	assert.True(t, exists)
 }
 
+func TestMap_RemoveIfAll(t *testing.T) {
+	am := Map(internal.GenerateTestMap())
+	assert.Equal(t, 7, am.Len())
+	am.RemoveIf(func(string, Value) bool {
+		return true
+	})
+	assert.Equal(t, 0, am.Len())
+}
+
 func generateTestEmptyMap(t *testing.T) Map {
 	m := NewMap()
 	assert.NoError(t, m.FromRaw(map[string]any{"k": map[string]any(nil)}))

pdata/pcommon/slice.go

@@ -134,6 +134,7 @@ func (es Slice) RemoveIf(f func(Value) bool) {
 	newLen := 0
 	for i := 0; i < len(*es.getOrig()); i++ {
 		if f(es.At(i)) {
+			(*es.getOrig())[i] = otlpcommon.AnyValue{}
 			continue
 		}
 		if newLen == i {
@@ -142,6 +143,7 @@ func (es Slice) RemoveIf(f func(Value) bool) {
 			continue
 		}
 		(*es.getOrig())[newLen] = (*es.getOrig())[i]
+		(*es.getOrig())[i] = otlpcommon.AnyValue{}
 		newLen++
 	}
 	*es.getOrig() = (*es.getOrig())[:newLen]

pdata/pcommon/slice_test.go

@@ -69,6 +69,14 @@ func TestSlice_CopyTo(t *testing.T) {
 	assert.Equal(t, Slice(internal.GenerateTestSlice()), dest)
 }
 
+func TestSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSlice()
+	src := Slice(internal.GenerateTestSlice())
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
+	assert.Equal(t, Slice(internal.GenerateTestSlice()), dest)
+}
+
 func TestSlice_EnsureCapacity(t *testing.T) {
 	es := Slice(internal.GenerateTestSlice())
 	// Test ensure smaller capacity.