v0.0.419 JsonOpt

dataext/optional.go

@@ -0,0 +1,67 @@
+package dataext
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+type JsonTwoWayMarshal interface {
+	json.Marshaler
+	json.Unmarshaler
+}
+
+type JsonOpt[T JsonTwoWayMarshal] struct {
+	isSet bool
+	value T
+}
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m JsonOpt[T]) MarshalJSON() ([]byte, error) {
+	if !m.isSet {
+		return []byte("null"), nil // actually this would be undefined - but undefined is not valid JSON
+	}
+
+	if m.value == nil {
+		return []byte("null"), nil
+	}
+
+	return m.MarshalJSON()
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *JsonOpt[T]) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("JsonOpt: UnmarshalJSON on nil pointer")
+	}
+
+	return m.value.UnmarshalJSON(data)
+}
+
+func (m JsonOpt[T]) IsSet() bool {
+	return m.isSet
+}
+
+func (m JsonOpt[T]) IsUnset() bool {
+	return !m.isSet
+}
+
+func (m JsonOpt[T]) Value() (T, bool) {
+	if !m.isSet {
+		return *new(T), false
+	}
+	return m.value, true
+}
+
+func (m JsonOpt[T]) ValueOrNil() *T {
+	if !m.isSet {
+		return nil
+	}
+	return &m.value
+}
+
+func (m JsonOpt[T]) MustValue() T {
+	if !m.isSet {
+		panic("value not set")
+	}
+	return m.value
+}

ginext/engine.go

@@ -194,3 +194,9 @@ func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
 	w.engine.ServeHTTP(respRec, req)
 	return respRec
 }
+
+// ForwardRequest manually inserts a request into this router
+// = behaves as if the request came from the outside (and writes the response to `writer`)
+func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
+	w.engine.ServeHTTP(writer, req)
+}

go.mod

@@ -1,6 +1,6 @@
 module gogs.mikescher.com/BlackForestBytes/goext
 
-go 1.21
+go 1.22
 
 require (
 	github.com/gin-gonic/gin v1.9.1
@@ -36,7 +36,7 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/montanaflynn/stats v0.7.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.1.1 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect

go.sum

@@ -104,6 +104,8 @@ github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8
 github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
 github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pelletier/go-toml/v2 v2.2.0 h1:QLgLl2yMN7N+ruc31VynXs1vhMZa7CeHHejIeBAsoHo=
+github.com/pelletier/go-toml/v2 v2.2.0/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -118,6 +120,7 @@ github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWR
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -126,6 +129,8 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.414"
+const GoextVersion = "0.0.419"
 
-const GoextVersionTimestamp = "2024-03-16T19:42:59+0100"
+const GoextVersionTimestamp = "2024-03-23T17:49:56+0100"

gojson/decode.go

@@ -217,6 +217,7 @@ type decodeState struct {
 	savedError            error
 	useNumber             bool
 	disallowUnknownFields bool
+	tagkey                *string
 }
 
 // readIndex returns the position of the last byte read.
@@ -652,7 +653,11 @@ func (d *decodeState) object(v reflect.Value) error {
 			v.Set(reflect.MakeMap(t))
 		}
 	case reflect.Struct:
-		fields = cachedTypeFields(t)
+		tagkey := "json"
+		if d.tagkey != nil {
+			tagkey = *d.tagkey
+		}
+		fields = cachedTypeFields(t, tagkey)
 		// ok
 	default:
 		d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})

gojson/encode.go

@@ -382,7 +382,12 @@ func isEmptyValue(v reflect.Value) bool {
 }
 
 func (e *encodeState) reflectValue(v reflect.Value, opts encOpts) {
-	valueEncoder(v)(e, v, opts)
+	tagkey := "json"
+	if opts.tagkey != nil {
+		tagkey = *opts.tagkey
+	}
+
+	valueEncoder(v, tagkey)(e, v, opts)
 }
 
 type encOpts struct {
@@ -397,20 +402,22 @@ type encOpts struct {
 	// filter matches jsonfilter tag of struct
 	// marshals if no jsonfilter is set or otherwise if jsonfilter has the filter value
 	filter *string
+	// use different tag instead of "json"
+	tagkey *string
 }
 
 type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts)
 
 var encoderCache sync.Map // map[reflect.Type]encoderFunc
 
-func valueEncoder(v reflect.Value) encoderFunc {
+func valueEncoder(v reflect.Value, tagkey string) encoderFunc {
 	if !v.IsValid() {
 		return invalidValueEncoder
 	}
-	return typeEncoder(v.Type())
+	return typeEncoder(v.Type(), tagkey)
 }
 
-func typeEncoder(t reflect.Type) encoderFunc {
+func typeEncoder(t reflect.Type, tagkey string) encoderFunc {
 	if fi, ok := encoderCache.Load(t); ok {
 		return fi.(encoderFunc)
 	}
@@ -433,7 +440,7 @@ func typeEncoder(t reflect.Type) encoderFunc {
 	}
 
 	// Compute the real encoder and replace the indirect func with it.
-	f = newTypeEncoder(t, true)
+	f = newTypeEncoder(t, true, tagkey)
 	wg.Done()
 	encoderCache.Store(t, f)
 	return f
@@ -446,19 +453,19 @@ var (
 
 // newTypeEncoder constructs an encoderFunc for a type.
 // The returned encoder only checks CanAddr when allowAddr is true.
-func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
+func newTypeEncoder(t reflect.Type, allowAddr bool, tagkey string) encoderFunc {
 	// If we have a non-pointer value whose type implements
 	// Marshaler with a value receiver, then we're better off taking
 	// the address of the value - otherwise we end up with an
 	// allocation as we cast the value to an interface.
 	if t.Kind() != reflect.Pointer && allowAddr && reflect.PointerTo(t).Implements(marshalerType) {
-		return newCondAddrEncoder(addrMarshalerEncoder, newTypeEncoder(t, false))
+		return newCondAddrEncoder(addrMarshalerEncoder, newTypeEncoder(t, false, tagkey))
 	}
 	if t.Implements(marshalerType) {
 		return marshalerEncoder
 	}
 	if t.Kind() != reflect.Pointer && allowAddr && reflect.PointerTo(t).Implements(textMarshalerType) {
-		return newCondAddrEncoder(addrTextMarshalerEncoder, newTypeEncoder(t, false))
+		return newCondAddrEncoder(addrTextMarshalerEncoder, newTypeEncoder(t, false, tagkey))
 	}
 	if t.Implements(textMarshalerType) {
 		return textMarshalerEncoder
@@ -480,15 +487,15 @@ func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
 	case reflect.Interface:
 		return interfaceEncoder
 	case reflect.Struct:
-		return newStructEncoder(t)
+		return newStructEncoder(t, tagkey)
 	case reflect.Map:
-		return newMapEncoder(t)
+		return newMapEncoder(t, tagkey)
 	case reflect.Slice:
-		return newSliceEncoder(t)
+		return newSliceEncoder(t, tagkey)
 	case reflect.Array:
-		return newArrayEncoder(t)
+		return newArrayEncoder(t, tagkey)
 	case reflect.Pointer:
-		return newPtrEncoder(t)
+		return newPtrEncoder(t, tagkey)
 	default:
 		return unsupportedTypeEncoder
 	}
@@ -801,8 +808,8 @@ FieldLoop:
 	}
 }
 
-func newStructEncoder(t reflect.Type) encoderFunc {
-	se := structEncoder{fields: cachedTypeFields(t)}
+func newStructEncoder(t reflect.Type, tagkey string) encoderFunc {
+	se := structEncoder{fields: cachedTypeFields(t, tagkey)}
 	return se.encode
 }
 
@@ -855,7 +862,7 @@ func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.ptrLevel--
 }
 
-func newMapEncoder(t reflect.Type) encoderFunc {
+func newMapEncoder(t reflect.Type, tagkey string) encoderFunc {
 	switch t.Key().Kind() {
 	case reflect.String,
 		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
@@ -865,7 +872,7 @@ func newMapEncoder(t reflect.Type) encoderFunc {
 			return unsupportedTypeEncoder
 		}
 	}
-	me := mapEncoder{typeEncoder(t.Elem())}
+	me := mapEncoder{typeEncoder(t.Elem(), tagkey)}
 	return me.encode
 }
 
@@ -936,7 +943,7 @@ func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.ptrLevel--
 }
 
-func newSliceEncoder(t reflect.Type) encoderFunc {
+func newSliceEncoder(t reflect.Type, tagkey string) encoderFunc {
 	// Byte slices get special treatment; arrays don't.
 	if t.Elem().Kind() == reflect.Uint8 {
 		p := reflect.PointerTo(t.Elem())
@@ -944,7 +951,7 @@ func newSliceEncoder(t reflect.Type) encoderFunc {
 			return encodeByteSlice
 		}
 	}
-	enc := sliceEncoder{newArrayEncoder(t)}
+	enc := sliceEncoder{newArrayEncoder(t, tagkey)}
 	return enc.encode
 }
 
@@ -964,8 +971,8 @@ func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.WriteByte(']')
 }
 
-func newArrayEncoder(t reflect.Type) encoderFunc {
-	enc := arrayEncoder{typeEncoder(t.Elem())}
+func newArrayEncoder(t reflect.Type, tagkey string) encoderFunc {
+	enc := arrayEncoder{typeEncoder(t.Elem(), tagkey)}
 	return enc.encode
 }
 
@@ -992,8 +999,8 @@ func (pe ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.ptrLevel--
 }
 
-func newPtrEncoder(t reflect.Type) encoderFunc {
-	enc := ptrEncoder{typeEncoder(t.Elem())}
+func newPtrEncoder(t reflect.Type, tagkey string) encoderFunc {
+	enc := ptrEncoder{typeEncoder(t.Elem(), tagkey)}
 	return enc.encode
 }
 
@@ -1270,7 +1277,7 @@ func (x byIndex) Less(i, j int) bool {
 // typeFields returns a list of fields that JSON should recognize for the given type.
 // The algorithm is breadth-first search over the set of structs to include - the top struct
 // and then any reachable anonymous structs.
-func typeFields(t reflect.Type) structFields {
+func typeFields(t reflect.Type, tagkey string) structFields {
 	// Anonymous fields to explore at the current level and the next.
 	current := []field{}
 	next := []field{{typ: t}}
@@ -1315,7 +1322,7 @@ func typeFields(t reflect.Type) structFields {
 					// Ignore unexported non-embedded fields.
 					continue
 				}
-				tag := sf.Tag.Get("json")
+				tag := sf.Tag.Get(tagkey)
 				if tag == "-" {
 					continue
 				}
@@ -1449,7 +1456,7 @@ func typeFields(t reflect.Type) structFields {
 
 	for i := range fields {
 		f := &fields[i]
-		f.encoder = typeEncoder(typeByIndex(t, f.index))
+		f.encoder = typeEncoder(typeByIndex(t, f.index), tagkey)
 	}
 	nameIndex := make(map[string]int, len(fields))
 	for i, field := range fields {
@@ -1474,13 +1481,26 @@ func dominantField(fields []field) (field, bool) {
 	return fields[0], true
 }
 
-var fieldCache sync.Map // map[reflect.Type]structFields
+var fieldCache sync.Map // map[string]map[reflect.Type]structFields
 
 // cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
-func cachedTypeFields(t reflect.Type) structFields {
-	if f, ok := fieldCache.Load(t); ok {
+func cachedTypeFields(t reflect.Type, tagkey string) structFields {
+	if m0, ok := fieldCache.Load(tagkey); ok {
+
+		if f, ok := m0.(*sync.Map).Load(t); ok {
+			return f.(structFields)
+		}
+		f, _ := m0.(*sync.Map).LoadOrStore(t, typeFields(t, tagkey))
+		return f.(structFields)
+
+	} else {
+
+		m0 := &sync.Map{}
+		f, _ := m0.LoadOrStore(t, typeFields(t, tagkey))
+
+		fieldCache.Store(tagkey, m0)
+
 		return f.(structFields)
 	}
-	f, _ := fieldCache.LoadOrStore(t, typeFields(t))
-	return f.(structFields)
+
 }

gojson/stream.go

@@ -41,6 +41,9 @@ func (dec *Decoder) UseNumber() { dec.d.useNumber = true }
 // non-ignored, exported fields in the destination.
 func (dec *Decoder) DisallowUnknownFields() { dec.d.disallowUnknownFields = true }
 
+// TagKey sets a different TagKey (instead of "json")
+func (dec *Decoder) TagKey(v string) { dec.d.tagkey = &v }
+
 // Decode reads the next JSON-encoded value from its
 // input and stores it in the value pointed to by v.
 //

reflectext/convertToMap.go

@@ -1,19 +1,30 @@
 package reflectext
 
-import "reflect"
+import (
+	"encoding/json"
+	"reflect"
+)
 
-func ConvertStructToMap(v any) any {
-	return reflectToMap(reflect.ValueOf(v))
+type ConvertStructToMapOpt struct {
+	KeepJsonMarshalTypes bool
 }
 
-func reflectToMap(fv reflect.Value) any {
+func ConvertStructToMap(v any, opts ...ConvertStructToMapOpt) any {
+	opt := ConvertStructToMapOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+	return reflectToMap(reflect.ValueOf(v), opt)
+}
+
+func reflectToMap(fv reflect.Value, opt ConvertStructToMapOpt) any {
 
 	if fv.Kind() == reflect.Ptr {
 
 		if fv.IsNil() {
 			return nil
 		} else {
-			return reflectToMap(fv.Elem())
+			return reflectToMap(fv.Elem(), opt)
 		}
 
 	}
@@ -30,7 +41,7 @@ func reflectToMap(fv reflect.Value) any {
 		arrlen := fv.Len()
 		arr := make([]any, arrlen)
 		for i := 0; i < arrlen; i++ {
-			arr[i] = reflectToMap(fv.Index(i))
+			arr[i] = reflectToMap(fv.Index(i), opt)
 		}
 		return arr
 
@@ -41,7 +52,7 @@ func reflectToMap(fv reflect.Value) any {
 		arrlen := fv.Len()
 		arr := make([]any, arrlen)
 		for i := 0; i < arrlen; i++ {
-			arr[i] = reflectToMap(fv.Index(i))
+			arr[i] = reflectToMap(fv.Index(i), opt)
 		}
 		return arr
 
@@ -56,11 +67,15 @@ func reflectToMap(fv reflect.Value) any {
 
 	if fv.Kind() == reflect.Struct {
 
+		if opt.KeepJsonMarshalTypes && fv.Type().Implements(reflect.TypeFor[json.Marshaler]()) {
+			return fv.Interface()
+		}
+
 		res := make(map[string]any)
 
 		for i := 0; i < fv.NumField(); i++ {
 			if fv.Type().Field(i).IsExported() {
-				res[fv.Type().Field(i).Name] = reflectToMap(fv.Field(i))
+				res[fv.Type().Field(i).Name] = reflectToMap(fv.Field(i), opt)
 			}
 		}