Remove support to set map and array to attribute value

This makes things consistent with other generated code where we do not allow
to set non immutable fields.

User can get access to the Map/Array and change that in-place.

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

consumer/pdata/common.go

@@ -269,60 +269,7 @@ func (a AttributeValue) SetBoolVal(v bool) {
 	(*a.orig).Value = &otlpcommon.AnyValue_BoolValue{BoolValue: v}
 }
 
-// SetMapVal replaces the value associated with this AttributeValue,
-// it also changes the type to be AttributeValueMAP. The `m` argument will be deep
-// copied into this AttributeValue.
-//
-// Calling this function on zero-initialized AttributeValue will cause a panic.
-func (a AttributeValue) SetMapVal(m AttributeMap) {
-	if *a.orig == nil {
-		*a.orig = &otlpcommon.AnyValue{}
-	}
-	var dest *otlpcommon.KeyValueList
-	switch v := (*a.orig).Value.(type) {
-	case *otlpcommon.AnyValue_KvlistValue:
-		if v.KvlistValue == nil {
-			v.KvlistValue = &otlpcommon.KeyValueList{}
-		}
-		dest = v.KvlistValue
-
-	default:
-		dest = &otlpcommon.KeyValueList{}
-		(*a.orig).Value = &otlpcommon.AnyValue_KvlistValue{KvlistValue: dest}
-	}
-
-	destMap := newAttributeMap(&dest.Values)
-	destMap.InitFromAttributeMap(m)
-}
-
-// SetArrayVal replaces the value associated with this AttributeValue,
-// it also changes the type to be AttributeValueARRAY. The `arr` argument will be deep
-// copied into this AttributeValue.
-//
-// Calling this function on zero-initialized AttributeValue will cause a panic.
-func (a AttributeValue) SetArrayVal(arr AnyValueArray) {
-	if *a.orig == nil {
-		*a.orig = &otlpcommon.AnyValue{}
-	}
-	var dest *otlpcommon.ArrayValue
-	switch v := (*a.orig).Value.(type) {
-	case *otlpcommon.AnyValue_ArrayValue:
-		if v.ArrayValue == nil {
-			v.ArrayValue = &otlpcommon.ArrayValue{}
-		}
-		dest = v.ArrayValue
-
-	default:
-		dest = &otlpcommon.ArrayValue{}
-		(*a.orig).Value = &otlpcommon.AnyValue_ArrayValue{ArrayValue: dest}
-	}
-
-	destArr := newAnyValueArray(&dest.Values)
-	arr.CopyTo(destArr)
-}
-
 // copyTo copies the value to AnyValue. Will panic if dest is nil.
-// Calling this function on zero-initialized AttributeValue will cause a panic.
 func (a AttributeValue) copyTo(dest *otlpcommon.AnyValue) {
 	if *a.orig == nil {
 		// This is a null value. Make the dest null too.
@@ -331,21 +278,29 @@ func (a AttributeValue) copyTo(dest *otlpcommon.AnyValue) {
 	}
 	switch v := (*a.orig).Value.(type) {
 	case *otlpcommon.AnyValue_KvlistValue:
+		kv, ok := dest.Value.(*otlpcommon.AnyValue_KvlistValue)
+		if !ok {
+			kv = &otlpcommon.AnyValue_KvlistValue{KvlistValue: &otlpcommon.KeyValueList{}}
+			dest.Value = kv
+		}
 		if v.KvlistValue == nil {
-			// Source is empty.
-			AttributeValue{&dest}.SetMapVal(NewAttributeMap())
-		} else {
-			// Deep copy to dest.
-			AttributeValue{&dest}.SetMapVal(newAttributeMap(&v.KvlistValue.Values))
+			kv.KvlistValue = nil
+			return
 		}
+		// Deep copy to dest.
+		newAttributeMap(&v.KvlistValue.Values).CopyTo(newAttributeMap(&kv.KvlistValue.Values))
 	case *otlpcommon.AnyValue_ArrayValue:
+		av, ok := dest.Value.(*otlpcommon.AnyValue_ArrayValue)
+		if !ok {
+			av = &otlpcommon.AnyValue_ArrayValue{ArrayValue: &otlpcommon.ArrayValue{}}
+			dest.Value = av
+		}
 		if v.ArrayValue == nil {
-			// Source is empty.
-			AttributeValue{&dest}.SetArrayVal(NewAnyValueArray())
-		} else {
-			// Deep copy to dest.
-			AttributeValue{&dest}.SetArrayVal(newAnyValueArray(&v.ArrayValue.Values))
+			av.ArrayValue = nil
+			return
 		}
+		// Deep copy to dest.
+		newAnyValueArray(&v.ArrayValue.Values).CopyTo(newAnyValueArray(&av.ArrayValue.Values))
 	default:
 		// Primitive immutable type, no need for deep copy.
 		dest.Value = (*a.orig).Value

consumer/pdata/common_test.go

@@ -89,13 +89,12 @@ func fromVal(v interface{}) AttributeValue {
 }
 
 func fromMap(v map[string]interface{}) AttributeValue {
-	m := NewAttributeMap()
+	av := NewAttributeValueMap()
+	m := av.MapVal()
 	for k, v := range v {
 		m.Insert(k, fromVal(v))
 	}
 	m.Sort()
-	av := NewAttributeValueMap()
-	av.SetMapVal(m)
 	return av
 }
 
@@ -224,16 +223,6 @@ func TestNilOrigSetAttributeValue(t *testing.T) {
 	av = createNilOrigSetAttributeValue()
 	av.SetDoubleVal(1.23)
 	assert.EqualValues(t, 1.23, av.DoubleVal())
-
-	av = createNilOrigSetAttributeValue()
-	av.SetMapVal(NewAttributeMap())
-	assert.EqualValues(t, NewAttributeMap(), av.MapVal())
-
-	// Test nil KvlistValue case for MapVal() func.
-	orig := &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_KvlistValue{KvlistValue: nil}}
-	av = AttributeValue{orig: &orig}
-	av.SetMapVal(NewAttributeMap())
-	assert.EqualValues(t, NewAttributeMap(), av.MapVal())
 }
 
 func TestAttributeValueEqual(t *testing.T) {
@@ -1052,12 +1041,11 @@ func generateTestBoolAttributeMap() AttributeMap {
 }
 
 func fromArray(v []interface{}) AttributeValue {
-	arr := NewAnyValueArray()
+	av := NewAttributeValueArray()
+	arr := av.ArrayVal()
 	for _, v := range v {
 		arr.Append(fromVal(v))
 	}
-	av := NewAttributeValueArray()
-	av.SetArrayVal(arr)
 	return av
 }
 
@@ -1118,35 +1106,6 @@ func TestAttributeValueArray(t *testing.T) {
 	assert.EqualValues(t, NewAnyValueArray(), a1.ArrayVal())
 }
 
-func TestAttributeValueSetArrayVal(t *testing.T) {
-	var anyVal *otlpcommon.AnyValue
-	v := newAttributeValue(&anyVal)
-	assert.EqualValues(t, AttributeValueNULL, v.Type())
-
-	v.SetArrayVal(NewAnyValueArray())
-	assert.EqualValues(t, AttributeValueARRAY, v.Type())
-
-	anyVal = &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_ArrayValue{}}
-	v = newAttributeValue(&anyVal)
-	assert.EqualValues(t, AttributeValueARRAY, v.Type())
-
-	v.SetArrayVal(NewAnyValueArray())
-	assert.EqualValues(t, AttributeValueARRAY, v.Type())
-
-	v.SetIntVal(123)
-	assert.EqualValues(t, AttributeValueINT, v.Type())
-
-	v.SetArrayVal(NewAnyValueArray())
-	assert.EqualValues(t, AttributeValueARRAY, v.Type())
-	assert.EqualValues(t, 0, v.ArrayVal().Len())
-
-	av := NewAnyValueArray()
-	av.Resize(1)
-	v.SetArrayVal(av)
-	assert.EqualValues(t, AttributeValueARRAY, v.Type())
-	assert.EqualValues(t, 1, v.ArrayVal().Len())
-}
-
 func TestAnyValueArrayWithNilValues(t *testing.T) {
 	origWithNil := []*otlpcommon.AnyValue{
 		nil,

exporter/loggingexporter/logging_exporter_test.go

@@ -72,18 +72,16 @@ func TestLoggingLogsExporterNoErrors(t *testing.T) {
 }
 
 func TestNestedArraySerializesCorrectly(t *testing.T) {
-	av := pdata.NewAnyValueArray()
 	ava := pdata.NewAttributeValueArray()
+	av := ava.ArrayVal()
 	av.Append(pdata.NewAttributeValueString("foo"))
 	av.Append(pdata.NewAttributeValueInt(42))
 
-	av2 := pdata.NewAnyValueArray()
-	av2.Append(pdata.NewAttributeValueString("bar"))
 	ava2 := pdata.NewAttributeValueArray()
-	ava2.SetArrayVal(av2)
+	av2 := ava2.ArrayVal()
+	av2.Append(pdata.NewAttributeValueString("bar"))
 
 	av.Append(ava2)
-	ava.SetArrayVal(av)
 
 	assert.Equal(t, 3, ava.ArrayVal().Len())
 	assert.Equal(t, "[foo, 42, [bar]]", attributeValueToString(ava))