v0.0.315 atomic

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.313"
+const GoextVersion = "0.0.315"
 
-const GoextVersionTimestamp = "2023-11-10T13:26:30+0100"
+const GoextVersionTimestamp = "2023-11-12T03:10:55+0100"

mongoext/registry.go

@@ -5,6 +5,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
 	"reflect"
 )
@@ -18,18 +19,21 @@ func CreateGoExtBsonRegistry() *bsoncodec.Registry {
 	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
 	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.UnixTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.UnixTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixTime{}), rfctime.UnixTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixTime{}), rfctime.UnixTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.UnixMilliTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.UnixMilliTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.UnixNanoTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.UnixNanoTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
 
 	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.Date{}), rfctime.Date{})
 	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.Date{}), rfctime.Date{})
 
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.SecondsF64(0)), rfctime.SecondsF64(0))
+	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
+
 	bsoncodec.DefaultValueEncoders{}.RegisterDefaultEncoders(rb)
 	bsoncodec.DefaultValueDecoders{}.RegisterDefaultDecoders(rb)
 

rfctime/seconds.go

@@ -2,7 +2,14 @@ package rfctime
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"reflect"
 	"time"
 )
 
@@ -54,6 +61,63 @@ func (d SecondsF64) MarshalJSON() ([]byte, error) {
 	return json.Marshal(secs)
 }
 
+func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+	if bt == bson.TypeNull {
+		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
+		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
+		// https://stackoverflow.com/questions/75167597
+		// https://jira.mongodb.org/browse/GODRIVER-2252
+		*d = SecondsF64(0)
+		return nil
+	}
+	if bt != bson.TypeDouble {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bt))
+	}
+	var tt float64
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*d = SecondsF64(tt)
+	return nil
+}
+
+func (d SecondsF64) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(d.Seconds())
+}
+
+func (d SecondsF64) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return errors.New("ValueUnmarshalerDecodeValue")
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	err = d.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&d))
+	} else {
+		val.Set(reflect.ValueOf(d))
+	}
+
+	return nil
+}
+
 func NewSecondsF64(t time.Duration) SecondsF64 {
 	return SecondsF64(t)
 }

rfctime/unix.go

@@ -76,7 +76,7 @@ func (t *UnixTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		return nil
 	}
 	if bt != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixTime", bt))
 	}
 	var tt time.Time
 	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)

rfctime/unixMilli.go

@@ -76,7 +76,7 @@ func (t *UnixMilliTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		return nil
 	}
 	if bt != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixMilliTime", bt))
 	}
 	var tt time.Time
 	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)

rfctime/unixNano.go

@@ -76,7 +76,7 @@ func (t *UnixNanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		return nil
 	}
 	if bt != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixNanoTime", bt))
 	}
 	var tt time.Time
 	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)

syncext/atomic.go

@@ -1,33 +1,28 @@
 package syncext
 
 import (
-	"context"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"sync"
-	"time"
 )
 
-type AtomicBool struct {
-	v        bool
-	listener map[string]chan bool
-	lock     sync.Mutex
+type Atomic[T any] struct {
+	v    T
+	lock sync.RWMutex
 }
 
-func NewAtomicBool(value bool) *AtomicBool {
-	return &AtomicBool{
-		v:        value,
-		listener: make(map[string]chan bool),
-		lock:     sync.Mutex{},
+func NewAtomic[T any](value T) *Atomic[T] {
+	return &Atomic[T]{
+		v:    value,
+		lock: sync.RWMutex{},
 	}
 }
 
-func (a *AtomicBool) Get() bool {
-	a.lock.Lock()
-	defer a.lock.Unlock()
+func (a *Atomic[T]) Get() T {
+	a.lock.RLock()
+	defer a.lock.RUnlock()
 	return a.v
 }
 
-func (a *AtomicBool) Set(value bool) bool {
+func (a *Atomic[T]) Set(value T) T {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
@@ -35,79 +30,5 @@ func (a *AtomicBool) Set(value bool) bool {
 
 	a.v = value
 
-	for k, v := range a.listener {
-		select {
-		case v <- value:
-			// message sent
-		default:
-			// no receiver on channel
-			delete(a.listener, k)
-		}
-	}
-
 	return oldValue
 }
-
-func (a *AtomicBool) Wait(waitFor bool) {
-	_ = a.WaitWithContext(context.Background(), waitFor)
-}
-
-func (a *AtomicBool) WaitWithTimeout(timeout time.Duration, waitFor bool) error {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	return a.WaitWithContext(ctx, waitFor)
-}
-
-func (a *AtomicBool) WaitWithContext(ctx context.Context, waitFor bool) error {
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-
-	if a.Get() == waitFor {
-		return nil
-	}
-
-	uuid, _ := langext.NewHexUUID()
-
-	waitchan := make(chan bool)
-
-	a.lock.Lock()
-	a.listener[uuid] = waitchan
-	a.lock.Unlock()
-	defer func() {
-		a.lock.Lock()
-		delete(a.listener, uuid)
-		a.lock.Unlock()
-	}()
-
-	for {
-		if err := ctx.Err(); err != nil {
-			return err
-		}
-
-		timeOut := 1024 * time.Millisecond
-
-		if dl, ok := ctx.Deadline(); ok {
-			timeOutMax := dl.Sub(time.Now())
-			if timeOutMax <= 0 {
-				timeOut = 0
-			} else if 0 < timeOutMax && timeOutMax < timeOut {
-				timeOut = timeOutMax
-			}
-		}
-
-		if v, ok := ReadChannelWithTimeout(waitchan, timeOut); ok {
-			if v == waitFor {
-				return nil
-			}
-		} else {
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-
-			if a.Get() == waitFor {
-				return nil
-			}
-		}
-	}
-}

syncext/bool.go

@@ -0,0 +1,113 @@
+package syncext
+
+import (
+	"context"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"sync"
+	"time"
+)
+
+type AtomicBool struct {
+	v        bool
+	listener map[string]chan bool
+	lock     sync.Mutex
+}
+
+func NewAtomicBool(value bool) *AtomicBool {
+	return &AtomicBool{
+		v:        value,
+		listener: make(map[string]chan bool),
+		lock:     sync.Mutex{},
+	}
+}
+
+func (a *AtomicBool) Get() bool {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	return a.v
+}
+
+func (a *AtomicBool) Set(value bool) bool {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+
+	oldValue := a.v
+
+	a.v = value
+
+	for k, v := range a.listener {
+		select {
+		case v <- value:
+			// message sent
+		default:
+			// no receiver on channel
+			delete(a.listener, k)
+		}
+	}
+
+	return oldValue
+}
+
+func (a *AtomicBool) Wait(waitFor bool) {
+	_ = a.WaitWithContext(context.Background(), waitFor)
+}
+
+func (a *AtomicBool) WaitWithTimeout(timeout time.Duration, waitFor bool) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	return a.WaitWithContext(ctx, waitFor)
+}
+
+func (a *AtomicBool) WaitWithContext(ctx context.Context, waitFor bool) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
+	if a.Get() == waitFor {
+		return nil
+	}
+
+	uuid, _ := langext.NewHexUUID()
+
+	waitchan := make(chan bool)
+
+	a.lock.Lock()
+	a.listener[uuid] = waitchan
+	a.lock.Unlock()
+	defer func() {
+		a.lock.Lock()
+		delete(a.listener, uuid)
+		a.lock.Unlock()
+	}()
+
+	for {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		timeOut := 1024 * time.Millisecond
+
+		if dl, ok := ctx.Deadline(); ok {
+			timeOutMax := dl.Sub(time.Now())
+			if timeOutMax <= 0 {
+				timeOut = 0
+			} else if 0 < timeOutMax && timeOutMax < timeOut {
+				timeOut = timeOutMax
+			}
+		}
+
+		if v, ok := ReadChannelWithTimeout(waitchan, timeOut); ok {
+			if v == waitFor {
+				return nil
+			}
+		} else {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
+			if a.Get() == waitFor {
+				return nil
+			}
+		}
+	}
+}