rebase: update kubernetes to 1.26.1

update kubernetes and its dependencies
to v1.26.1

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/go.opentelemetry.io/otel/attribute/value.go

@@ -17,7 +17,6 @@ package attribute // import "go.opentelemetry.io/otel/attribute"
 import (
 	"encoding/json"
 	"fmt"
-	"reflect"
 	"strconv"
 
 	"go.opentelemetry.io/otel/internal"
@@ -26,16 +25,14 @@ import (
 //go:generate stringer -type=Type
 
 // Type describes the type of the data Value holds.
-type Type int
+type Type int // nolint: revive  // redefines builtin Type.
 
 // Value represents the value part in key-value pairs.
 type Value struct {
 	vtype    Type
 	numeric  uint64
 	stringly string
-	// TODO Lazy value type?
-
-	array interface{}
+	slice    interface{}
 }
 
 const (
@@ -49,10 +46,14 @@ const (
 	FLOAT64
 	// STRING is a string Type Value.
 	STRING
-	// ARRAY is an array Type Value used to store 1-dimensional slices or
-	// arrays of bool, int, int32, int64, uint, uint32, uint64, float,
-	// float32, float64, or string types.
-	ARRAY
+	// BOOLSLICE is a slice of booleans Type Value.
+	BOOLSLICE
+	// INT64SLICE is a slice of 64-bit signed integral numbers Type Value.
+	INT64SLICE
+	// FLOAT64SLICE is a slice of 64-bit floating point numbers Type Value.
+	FLOAT64SLICE
+	// STRINGSLICE is a slice of strings Type Value.
+	STRINGSLICE
 )
 
 // BoolValue creates a BOOL Value.
@@ -63,6 +64,33 @@ func BoolValue(v bool) Value {
 	}
 }
 
+// BoolSliceValue creates a BOOLSLICE Value.
+func BoolSliceValue(v []bool) Value {
+	cp := make([]bool, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: BOOLSLICE,
+		slice: &cp,
+	}
+}
+
+// IntValue creates an INT64 Value.
+func IntValue(v int) Value {
+	return Int64Value(int64(v))
+}
+
+// IntSliceValue creates an INTSLICE Value.
+func IntSliceValue(v []int) Value {
+	cp := make([]int64, 0, len(v))
+	for _, i := range v {
+		cp = append(cp, int64(i))
+	}
+	return Value{
+		vtype: INT64SLICE,
+		slice: &cp,
+	}
+}
+
 // Int64Value creates an INT64 Value.
 func Int64Value(v int64) Value {
 	return Value{
@@ -71,6 +99,16 @@ func Int64Value(v int64) Value {
 	}
 }
 
+// Int64SliceValue creates an INT64SLICE Value.
+func Int64SliceValue(v []int64) Value {
+	cp := make([]int64, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: INT64SLICE,
+		slice: &cp,
+	}
+}
+
 // Float64Value creates a FLOAT64 Value.
 func Float64Value(v float64) Value {
 	return Value{
@@ -79,6 +117,16 @@ func Float64Value(v float64) Value {
 	}
 }
 
+// Float64SliceValue creates a FLOAT64SLICE Value.
+func Float64SliceValue(v []float64) Value {
+	cp := make([]float64, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: FLOAT64SLICE,
+		slice: &cp,
+	}
+}
+
 // StringValue creates a STRING Value.
 func StringValue(v string) Value {
 	return Value{
@@ -87,38 +135,14 @@ func StringValue(v string) Value {
 	}
 }
 
-// IntValue creates an INT64 Value.
-func IntValue(v int) Value {
-	return Int64Value(int64(v))
-}
-
-// ArrayValue creates an ARRAY value from an array or slice.
-// Only arrays or slices of bool, int, int64, float, float64, or string types are allowed.
-// Specifically, arrays  and slices can not contain other arrays, slices, structs, or non-standard
-// types. If the passed value is not an array or slice of these types an
-// INVALID value is returned.
-func ArrayValue(v interface{}) Value {
-	switch reflect.TypeOf(v).Kind() {
-	case reflect.Array, reflect.Slice:
-		// get array type regardless of dimensions
-		typ := reflect.TypeOf(v).Elem()
-		kind := typ.Kind()
-		switch kind {
-		case reflect.Bool, reflect.Int, reflect.Int64,
-			reflect.Float64, reflect.String:
-			val := reflect.ValueOf(v)
-			length := val.Len()
-			frozen := reflect.Indirect(reflect.New(reflect.ArrayOf(length, typ)))
-			reflect.Copy(frozen, val)
-			return Value{
-				vtype: ARRAY,
-				array: frozen.Interface(),
-			}
-		default:
-			return Value{vtype: INVALID}
-		}
+// StringSliceValue creates a STRINGSLICE Value.
+func StringSliceValue(v []string) Value {
+	cp := make([]string, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: STRINGSLICE,
+		slice: &cp,
 	}
-	return Value{vtype: INVALID}
 }
 
 // Type returns a type of the Value.
@@ -132,27 +156,58 @@ func (v Value) AsBool() bool {
 	return internal.RawToBool(v.numeric)
 }
 
+// AsBoolSlice returns the []bool value. Make sure that the Value's type is
+// BOOLSLICE.
+func (v Value) AsBoolSlice() []bool {
+	if s, ok := v.slice.(*[]bool); ok {
+		return *s
+	}
+	return nil
+}
+
 // AsInt64 returns the int64 value. Make sure that the Value's type is
 // INT64.
 func (v Value) AsInt64() int64 {
 	return internal.RawToInt64(v.numeric)
 }
 
+// AsInt64Slice returns the []int64 value. Make sure that the Value's type is
+// INT64SLICE.
+func (v Value) AsInt64Slice() []int64 {
+	if s, ok := v.slice.(*[]int64); ok {
+		return *s
+	}
+	return nil
+}
+
 // AsFloat64 returns the float64 value. Make sure that the Value's
 // type is FLOAT64.
 func (v Value) AsFloat64() float64 {
 	return internal.RawToFloat64(v.numeric)
 }
 
+// AsFloat64Slice returns the []float64 value. Make sure that the Value's type is
+// FLOAT64SLICE.
+func (v Value) AsFloat64Slice() []float64 {
+	if s, ok := v.slice.(*[]float64); ok {
+		return *s
+	}
+	return nil
+}
+
 // AsString returns the string value. Make sure that the Value's type
 // is STRING.
 func (v Value) AsString() string {
 	return v.stringly
 }
 
-// AsArray returns the array Value as an interface{}.
-func (v Value) AsArray() interface{} {
-	return v.array
+// AsStringSlice returns the []string value. Make sure that the Value's type is
+// STRINGSLICE.
+func (v Value) AsStringSlice() []string {
+	if s, ok := v.slice.(*[]string); ok {
+		return *s
+	}
+	return nil
 }
 
 type unknownValueType struct{}
@@ -160,16 +215,22 @@ type unknownValueType struct{}
 // AsInterface returns Value's data as interface{}.
 func (v Value) AsInterface() interface{} {
 	switch v.Type() {
-	case ARRAY:
-		return v.AsArray()
 	case BOOL:
 		return v.AsBool()
+	case BOOLSLICE:
+		return v.AsBoolSlice()
 	case INT64:
 		return v.AsInt64()
+	case INT64SLICE:
+		return v.AsInt64Slice()
 	case FLOAT64:
 		return v.AsFloat64()
+	case FLOAT64SLICE:
+		return v.AsFloat64Slice()
 	case STRING:
 		return v.stringly
+	case STRINGSLICE:
+		return v.AsStringSlice()
 	}
 	return unknownValueType{}
 }
@@ -177,14 +238,20 @@ func (v Value) AsInterface() interface{} {
 // Emit returns a string representation of Value's data.
 func (v Value) Emit() string {
 	switch v.Type() {
-	case ARRAY:
-		return fmt.Sprint(v.array)
+	case BOOLSLICE:
+		return fmt.Sprint(*(v.slice.(*[]bool)))
 	case BOOL:
 		return strconv.FormatBool(v.AsBool())
+	case INT64SLICE:
+		return fmt.Sprint(*(v.slice.(*[]int64)))
 	case INT64:
 		return strconv.FormatInt(v.AsInt64(), 10)
+	case FLOAT64SLICE:
+		return fmt.Sprint(*(v.slice.(*[]float64)))
 	case FLOAT64:
 		return fmt.Sprint(v.AsFloat64())
+	case STRINGSLICE:
+		return fmt.Sprint(*(v.slice.(*[]string)))
 	case STRING:
 		return v.stringly
 	default: