Merge pull request #132 from rebuy-de/add-dsutil

add typeutil

Author: svenwltr

go.mod

@@ -28,6 +28,7 @@ require (
 	github.com/spf13/cobra v1.6.1
 	github.com/stretchr/testify v1.8.1
 	github.com/tidwall/pretty v1.2.1
+	golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0
 	golang.org/x/oauth2 v0.4.0
 	golang.org/x/sync v0.1.0
 	golang.org/x/tools v0.5.0

go.sum

@@ -595,6 +595,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0 h1:pVgRXcIictcr+lBQIFeiwuwtDIs4eL21OuM9nyAADmo=
+golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=

pkg/typeutil/pointer.go

@@ -0,0 +1,22 @@
+package typeutil
+
+// Pointer creates a pointer from the given value. This is useful, when
+// creating a pointer from a loop variable [1] or when creating a pointer from
+// a return value of another function, since both would require assigning the
+// value to an intermediate variable first.
+//
+// [1]: https://github.com/golang/go/discussions/56010
+func Pointer[T any](v T) *T {
+	return &v
+}
+
+// Value returns the value from a pointer. If the pointer is nil, it will
+// return the zero value instead.
+func Value[T any](p *T) T {
+	if p != nil {
+		return *p
+	}
+
+	var zero T
+	return zero
+}

pkg/typeutil/set.go

@@ -0,0 +1,162 @@
+package typeutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+
+	"golang.org/x/exp/constraints"
+)
+
+// Set implements a set data structure based on built-in maps. This is not
+// optimized for large data, but to be convient.
+type Set[T constraints.Ordered] struct {
+	data map[T]struct{}
+}
+
+// NewSet initializes a new Set with the given values. If there are no values
+// provides this is equivalent to new(Set[T]).
+func NewSet[T constraints.Ordered](values ...T) *Set[T] {
+	s := new(Set[T])
+	for i := range values {
+		s.Add(values[i])
+	}
+	return s
+}
+
+// Add puts a single value to the set. The set will be the same, if it already
+// contains the value.
+func (s *Set[T]) Add(value T) {
+	if s.data == nil {
+		s.data = map[T]struct{}{}
+	}
+
+	s.data[value] = struct{}{}
+}
+
+// Contains returns true, if the given value is part of the set.
+func (s *Set[T]) Contains(value T) bool {
+	if s.data == nil {
+		return false
+	}
+
+	_, found := s.data[value]
+	return found
+}
+
+// Remove removes the given value from the set. The set will be the same, if
+// the value is not part of it.
+func (s *Set[T]) Remove(value T) {
+	if s.data == nil {
+		return
+	}
+
+	delete(s.data, value)
+}
+
+// Substract removes every element from the given set from the set.
+func (s *Set[T]) Subtract(other *Set[T]) {
+	if s.data == nil {
+		return
+	}
+
+	for value := range other.data {
+		delete(s.data, value)
+	}
+}
+
+// Len returns the number of all values in the set.
+func (s Set[T]) Len() int {
+	return len(s.data)
+}
+
+// ToList converts the set into a slice. Since the set uses a map as an
+// underlying data structure, this will copy each value. So it might be memory
+// intensive. Also it sorts the slice to ensure a cosistent result.
+func (s *Set[T]) ToList() []T {
+	if s == nil || s.data == nil {
+		return nil
+	}
+
+	list := make([]T, 0, len(s.data))
+
+	if len(s.data) > 0 {
+		for v := range s.data {
+			list = append(list, v)
+		}
+	}
+
+	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
+
+	return list
+}
+
+// AddSet adds each value from the given set to the set.
+func (s *Set[T]) AddSet(other *Set[T]) {
+	if other == nil {
+		return
+	}
+
+	for o := range other.data {
+		s.Add(o)
+	}
+}
+
+// MarshalJSON adds support for mashaling the set into a JSON list.
+func (s Set[T]) MarshalJSON() ([]byte, error) {
+	list := s.ToList()
+	return json.Marshal(list)
+}
+
+// MarshalJSON adds support for unmashaling the set from a JSON list.
+func (s *Set[T]) UnmarshalJSON(data []byte) error {
+	list := []T{}
+	err := json.Unmarshal(data, &list)
+	if err != nil {
+		return fmt.Errorf("unmarshal set: %w", err)
+	}
+
+	for _, v := range list {
+		s.Add(v)
+	}
+
+	return nil
+}
+
+func SetUnion[T constraints.Ordered](sets ...*Set[T]) *Set[T] {
+	result := new(Set[T])
+
+	for s := range sets {
+		result.AddSet(sets[s])
+	}
+
+	return result
+}
+
+// SetIntersect returns a set that only contains elements which exist in all
+// sets.
+func SetIntersect[T constraints.Ordered](sets ...*Set[T]) *Set[T] {
+	result := new(Set[T])
+
+	for _, s := range sets {
+		if s == nil || s.data == nil {
+			return result
+		}
+	}
+
+	if len(sets) == 0 {
+		return result
+	}
+
+	result.AddSet(sets[0])
+
+	for _, s := range sets[1:] {
+		for e := range result.data {
+			if !s.Contains(e) {
+				delete(result.data, e)
+			}
+		}
+	}
+
+	return result
+}

pkg/typeutil/set_test.go

@@ -0,0 +1,96 @@
+package typeutil
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSet(t *testing.T) {
+	toJSON := func(t *testing.T, set Set[string]) string {
+		data, err := json.Marshal(set)
+		assert.NoError(t, err)
+		return string(data)
+	}
+
+	fromJSON := func(t *testing.T, data string) Set[string] {
+		var set Set[string]
+		err := json.Unmarshal([]byte(data), &set)
+		assert.NoError(t, err)
+		return set
+	}
+
+	t.Run("Simple", func(t *testing.T) {
+		var set Set[string]
+		set.Add("foo")
+		set.Add("bar")
+		set.Add("bar")
+		assert.Equal(t, `["bar","foo"]`, toJSON(t, set))
+	})
+
+	t.Run("JSON", func(t *testing.T) {
+		in := `["bar","foo"]`
+		set := fromJSON(t, `["bar","foo"]`)
+		out := toJSON(t, set)
+
+		assert.Equal(t, in, out)
+	})
+}
+
+func TestSetUnion(t *testing.T) {
+	cases := []struct {
+		Name string
+		A, B *Set[string]
+		Want *Set[string]
+	}{
+		{
+			Name: "Simple",
+			A:    NewSet("a", "b", "c"),
+			B:    NewSet("c", "d", "e"),
+			Want: NewSet("a", "b", "c", "d", "e"),
+		},
+		{
+			Name: "NilB",
+			A:    NewSet("a", "b", "c"),
+			B:    nil,
+			Want: NewSet("a", "b", "c"),
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Name, func(t *testing.T) {
+			have := SetUnion(tc.A, tc.B)
+			require.Equal(t, tc.Want.ToList(), have.ToList())
+		})
+	}
+}
+
+func TestSetIntersection(t *testing.T) {
+	cases := []struct {
+		Name string
+		A, B *Set[string]
+		Want *Set[string]
+	}{
+		{
+			Name: "Simple",
+			A:    NewSet("a", "b", "c", "d"),
+			B:    NewSet("c", "d", "e"),
+			Want: NewSet("c", "d"),
+		},
+		{
+			Name: "NilB",
+			A:    NewSet("a", "b", "c"),
+			B:    nil,
+			Want: NewSet[string](),
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Name, func(t *testing.T) {
+			have := SetIntersect(tc.A, tc.B)
+			require.Equal(t, tc.Want.ToList(), have.ToList())
+		})
+	}
+}

pkg/typeutil/slice.go

@@ -0,0 +1,23 @@
+package typeutil
+
+func LimitSlice[T any](slice []T, limit int) ([]T, int) {
+	l := len(slice)
+
+	if l <= limit {
+		return slice, 0
+	}
+
+	return slice[0:limit], l - limit
+}
+
+func FilterSlice[T any](in []T, fn func(T) bool) []T {
+	result := []T{}
+
+	for i := range in {
+		if fn(in[i]) {
+			result = append(result, in[i])
+		}
+	}
+
+	return result
+}