Export ReverseSliceInPlace and ReverseSlice (b5e3f7da) · Commits · e / os / android_build_soong

android/arch.go

+2 −2

Original line number	Diff line number	Diff line
		@@ -1884,10 +1884,10 @@ func decodeMultilibTargets(multilib string, targets []Target, prefer32 bool) ([]
		buildTargets = filterMultilibTargets(targets, "lib64")
		// Reverse the targets so that the first architecture can depend on the second
		// architecture module in order to merge the outputs.
		reverseSliceInPlace(buildTargets)
		ReverseSliceInPlace(buildTargets)
		case "darwin_universal_common_first":
		archTargets := filterMultilibTargets(targets, "lib64")
		reverseSliceInPlace(archTargets)
		ReverseSliceInPlace(archTargets)
		buildTargets = append(getCommonTargets(targets), archTargets...)
		default:
		return nil, fmt.Errorf(`compile_multilib must be "both", "first", "32", "64", "prefer32" or "first_prefer32" found %q`,

+3 −3

Original line number	Diff line number	Diff line
		@@ -79,8 +79,8 @@ func NewDepSet[T depSettableType](order DepSetOrder, direct []T, transitive []*D
		if order == TOPOLOGICAL {
		// TOPOLOGICAL is implemented as a postorder traversal followed by reversing the output.
		// Pre-reverse the inputs here so their order is maintained in the output.
		directCopy = reverseSlice(direct)
		transitiveCopy = reverseSlice(transitive)
		directCopy = ReverseSlice(direct)
		transitiveCopy = ReverseSlice(transitive)
		} else {
		directCopy = append([]T(nil), direct...)
		transitiveCopy = append([]*DepSet[T](nil), transitive...)
		@@ -194,7 +194,7 @@ func (d *DepSet[T]) toList(firstUniqueFunc func([]T) []T) []T {
		})
		list = firstUniqueFunc(list)
		if d.reverse {
		reverseSliceInPlace(list)
		ReverseSliceInPlace(list)
		}
		return list
		}

+8 −4

Original line number	Diff line number	Diff line
		@@ -338,15 +338,19 @@ func firstUniqueMap[T comparable](in []T) []T {
		return in[0:writeIndex]
		}

		// reverseSliceInPlace reverses the elements of a slice in place.
		func reverseSliceInPlace[T any](in []T) {
		// ReverseSliceInPlace reverses the elements of a slice in place and returns it.
		func ReverseSliceInPlace[T any](in []T) []T {
		for i, j := 0, len(in)-1; i < j; i, j = i+1, j-1 {
		in[i], in[j] = in[j], in[i]
		}
		return in
		}

		// reverseSlice returns a copy of a slice in reverse order.
		func reverseSlice[T any](in []T) []T {
		// ReverseSlice returns a copy of a slice in reverse order.
		func ReverseSlice[T any](in []T) []T {
		if in == nil {
		return in
		}
		out := make([]T, len(in))
		for i := 0; i < len(in); i++ {
		out[i] = in[len(in)-1-i]

+63 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ import (
		"strconv"
		"strings"
		"testing"
		"unsafe"
		)

		var firstUniqueStringsTestCases = []struct {
		@@ -754,3 +755,65 @@ func TestSortedUniqueStringValues(t *testing.T) {
		})
		}
		}

		var reverseTestCases = []struct {
		name string
		in []string
		expected []string
		}{
		{
		name: "nil",
		in: nil,
		expected: nil,
		},
		{
		name: "empty",
		in: []string{},
		expected: []string{},
		},
		{
		name: "one",
		in: []string{"one"},
		expected: []string{"one"},
		},
		{
		name: "even",
		in: []string{"one", "two"},
		expected: []string{"two", "one"},
		},
		{
		name: "odd",
		in: []string{"one", "two", "three"},
		expected: []string{"three", "two", "one"},
		},
		}

		func TestReverseSliceInPlace(t *testing.T) {
		for _, testCase := range reverseTestCases {
		t.Run(testCase.name, func(t *testing.T) {
		slice := CopyOf(testCase.in)
		slice2 := slice
		ReverseSliceInPlace(slice)
		if !reflect.DeepEqual(slice, testCase.expected) {
		t.Errorf("expected %#v, got %#v", testCase.expected, slice)
		}
		if unsafe.SliceData(slice) != unsafe.SliceData(slice2) {
		t.Errorf("expected slices to share backing array")
		}
		})
		}
		}

		func TestReverseSlice(t *testing.T) {
		for _, testCase := range reverseTestCases {
		t.Run(testCase.name, func(t *testing.T) {
		slice := ReverseSlice(testCase.in)
		if !reflect.DeepEqual(slice, testCase.expected) {
		t.Errorf("expected %#v, got %#v", testCase.expected, slice)
		}
		if slice != nil && unsafe.SliceData(testCase.in) == unsafe.SliceData(slice) {
		t.Errorf("expected slices to have different backing arrays")
		}
		})
		}
		}