switch dictionary for line and function

Author: dmathieu

pdata/pprofile/function.go

@@ -3,10 +3,54 @@
 
 package pprofile // import "go.opentelemetry.io/collector/pdata/pprofile"
 
+import "fmt"
+
 // Equal checks equality with another Function
 func (fn Function) Equal(val Function) bool {
 	return fn.NameStrindex() == val.NameStrindex() &&
 		fn.SystemNameStrindex() == val.SystemNameStrindex() &&
 		fn.FilenameStrindex() == val.FilenameStrindex() &&
 		fn.StartLine() == val.StartLine()
 }
+
+// switchDictionary updates the Function, switching its indices from one
+// dictionary to another.
+func (ms Function) switchDictionary(src, dst ProfilesDictionary) error {
+	if ms.NameStrindex() > 0 {
+		if src.StringTable().Len() < int(ms.NameStrindex()) {
+			return fmt.Errorf("invalid name index %d", ms.NameStrindex())
+		}
+
+		idx, err := SetString(dst.StringTable(), src.StringTable().At(int(ms.NameStrindex())))
+		if err != nil {
+			return fmt.Errorf("couldn't set name: %w", err)
+		}
+		ms.SetNameStrindex(idx)
+	}
+
+	if ms.SystemNameStrindex() > 0 {
+		if src.StringTable().Len() < int(ms.SystemNameStrindex()) {
+			return fmt.Errorf("invalid system name index %d", ms.SystemNameStrindex())
+		}
+
+		idx, err := SetString(dst.StringTable(), src.StringTable().At(int(ms.SystemNameStrindex())))
+		if err != nil {
+			return fmt.Errorf("couldn't set system name: %w", err)
+		}
+		ms.SetSystemNameStrindex(idx)
+	}
+
+	if ms.FilenameStrindex() > 0 {
+		if src.StringTable().Len() < int(ms.FilenameStrindex()) {
+			return fmt.Errorf("invalid filename index %d", ms.FilenameStrindex())
+		}
+
+		idx, err := SetString(dst.StringTable(), src.StringTable().At(int(ms.FilenameStrindex())))
+		if err != nil {
+			return fmt.Errorf("couldn't set filename: %w", err)
+		}
+		ms.SetFilenameStrindex(idx)
+	}
+
+	return nil
+}

pdata/pprofile/function_test.go

@@ -4,9 +4,11 @@
 package pprofile
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFunctionEqual(t *testing.T) {
@@ -63,6 +65,193 @@ func TestFunctionEqual(t *testing.T) {
 	}
 }
 
+func TestFunctionSwitchDictionary(t *testing.T) {
+	for _, tt := range []struct {
+		name     string
+		function Function
+
+		src ProfilesDictionary
+		dst ProfilesDictionary
+
+		wantFunction   Function
+		wantDictionary ProfilesDictionary
+		wantErr        error
+	}{
+		{
+			name:     "with an empty key value and unit",
+			function: NewFunction(),
+
+			src: NewProfilesDictionary(),
+			dst: NewProfilesDictionary(),
+
+			wantFunction:   NewFunction(),
+			wantDictionary: NewProfilesDictionary(),
+		},
+		{
+			name: "with an existing name",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetNameStrindex(1)
+				return fn
+			}(),
+
+			src: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "test")
+				return d
+			}(),
+			dst: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo")
+				return d
+			}(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetNameStrindex(2)
+				return fn
+			}(),
+			wantDictionary: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo", "test")
+				return d
+			}(),
+		},
+		{
+			name: "with a name index that does not match anything",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetNameStrindex(1)
+				return fn
+			}(),
+
+			src: NewProfilesDictionary(),
+			dst: NewProfilesDictionary(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetNameStrindex(1)
+				return fn
+			}(),
+			wantDictionary: NewProfilesDictionary(),
+			wantErr:        errors.New("invalid name index 1"),
+		},
+		{
+			name: "with an existing system name",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetSystemNameStrindex(1)
+				return fn
+			}(),
+
+			src: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "test")
+				return d
+			}(),
+			dst: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo")
+				return d
+			}(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetSystemNameStrindex(2)
+				return fn
+			}(),
+			wantDictionary: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo", "test")
+				return d
+			}(),
+		},
+		{
+			name: "with a system name index that does not match anything",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetSystemNameStrindex(1)
+				return fn
+			}(),
+
+			src: NewProfilesDictionary(),
+			dst: NewProfilesDictionary(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetSystemNameStrindex(1)
+				return fn
+			}(),
+			wantDictionary: NewProfilesDictionary(),
+			wantErr:        errors.New("invalid system name index 1"),
+		},
+		{
+			name: "with an existing filename",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetFilenameStrindex(1)
+				return fn
+			}(),
+
+			src: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "test")
+				return d
+			}(),
+			dst: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo")
+				return d
+			}(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetFilenameStrindex(2)
+				return fn
+			}(),
+			wantDictionary: func() ProfilesDictionary {
+				d := NewProfilesDictionary()
+				d.StringTable().Append("", "foo", "test")
+				return d
+			}(),
+		},
+		{
+			name: "with a filename index that does not match anything",
+			function: func() Function {
+				fn := NewFunction()
+				fn.SetFilenameStrindex(1)
+				return fn
+			}(),
+
+			src: NewProfilesDictionary(),
+			dst: NewProfilesDictionary(),
+
+			wantFunction: func() Function {
+				fn := NewFunction()
+				fn.SetFilenameStrindex(1)
+				return fn
+			}(),
+			wantDictionary: NewProfilesDictionary(),
+			wantErr:        errors.New("invalid filename index 1"),
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			fn := tt.function
+			dst := tt.dst
+			err := fn.switchDictionary(tt.src, dst)
+
+			if tt.wantErr == nil {
+				require.NoError(t, err)
+			} else {
+				require.Equal(t, tt.wantErr, err)
+			}
+
+			assert.Equal(t, tt.wantFunction, fn)
+			assert.Equal(t, tt.wantDictionary, dst)
+		})
+	}
+}
+
 func buildFunction(name, sName, fileName int32, startLine int64) Function {
 	f := NewFunction()
 	f.SetNameStrindex(name)

pdata/pprofile/line.go

@@ -3,6 +3,8 @@
 
 package pprofile // import "go.opentelemetry.io/collector/pdata/pprofile"
 
+import "fmt"
+
 // Equal checks equality with another LineSlice
 func (l LineSlice) Equal(val LineSlice) bool {
 	if l.Len() != val.Len() {
@@ -24,3 +26,27 @@ func (l Line) Equal(val Line) bool {
 		l.FunctionIndex() == val.FunctionIndex() &&
 		l.Line() == val.Line()
 }
+
+// switchDictionary updates the Line, switching its indices from one
+// dictionary to another.
+func (l Line) switchDictionary(src, dst ProfilesDictionary) error {
+	if l.FunctionIndex() > 0 {
+		if src.FunctionTable().Len() < int(l.FunctionIndex()) {
+			return fmt.Errorf("invalid function index %d", l.FunctionIndex())
+		}
+
+		fn := src.FunctionTable().At(int(l.FunctionIndex()))
+		err := fn.switchDictionary(src, dst)
+		if err != nil {
+			return fmt.Errorf("couldn't switch function dictionary: %w", err)
+		}
+
+		idx, err := SetFunction(dst.FunctionTable(), fn)
+		if err != nil {
+			return fmt.Errorf("couldn't set function: %w", err)
+		}
+		l.SetFunctionIndex(idx)
+	}
+
+	return nil
+}