v0.0.52

Makefile

@@ -4,3 +4,6 @@ run:
 
 test:
 	go test ./...
+
+version:
+	_data/version.sh

_data/version.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -o nounset   # disallow usage of unset vars  ( set -u )
+set -o errexit   # Exit immediately if a pipeline returns non-zero.  ( set -e )
+set -o errtrace  # Allow the above trap be inherited by all functions in the script.  ( set -E )
+set -o pipefail  # Return value of a pipeline is the value of the last (rightmost) command to exit with a non-zero status
+IFS=$'\n\t'      # Set $IFS to only newline and tab.
+
+
+curr_vers=$(git describe --tags --abbrev=0 | sed 's/v//g')
+
+next_ver=$(echo "$curr_vers" | awk -F. -v OFS=. 'NF==1{print ++$NF}; NF>1{if(length($NF+1)>length($NF))$(NF-1)++; $NF=sprintf("%0*d", length($NF), ($NF+1)%(10^length($NF))); print}')
+
+echo ""
+echo "> Current Version: ${curr_vers}"
+echo "> Next    Version: ${next_ver}"
+echo ""
+
+git add --verbose .
+
+git commit -a -m "v${next_ver}"
+
+git tag "v${next_ver}"
+
+git push
+git push --tags
+

cmdext/cmdrunner.go

@@ -0,0 +1,142 @@
+package cmdext
+
+import (
+	"bufio"
+	"os/exec"
+	"time"
+)
+
+type CommandResult struct {
+	StdOut          string
+	StdErr          string
+	StdCombined     string
+	ExitCode        int
+	CommandTimedOut bool
+}
+
+func RunCommand(program string, args []string, timeout *time.Duration) (CommandResult, error) {
+
+	cmd := exec.Command(program, args...)
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	errch := make(chan error, 1)
+	go func() { errch <- cmd.Wait() }()
+
+	combch := make(chan string, 32)
+	stopCombch := make(chan bool)
+
+	stdout := ""
+	go func() {
+		scanner := bufio.NewScanner(stdoutPipe)
+		for scanner.Scan() {
+			txt := scanner.Text()
+			stdout += txt
+			combch <- txt
+		}
+	}()
+
+	stderr := ""
+	go func() {
+		scanner := bufio.NewScanner(stderrPipe)
+		for scanner.Scan() {
+			txt := scanner.Text()
+			stderr += txt
+			combch <- txt
+		}
+	}()
+
+	defer func() {
+		stopCombch <- true
+	}()
+
+	stdcombined := ""
+	go func() {
+		for {
+			select {
+			case txt := <-combch:
+				stdcombined += txt
+			case <-stopCombch:
+				return
+			}
+		}
+	}()
+
+	if timeout != nil {
+
+		select {
+
+		case <-time.After(*timeout):
+			_ = cmd.Process.Kill()
+			return CommandResult{
+				StdOut:          stdout,
+				StdErr:          stderr,
+				StdCombined:     stdcombined,
+				ExitCode:        -1,
+				CommandTimedOut: true,
+			}, nil
+
+		case err := <-errch:
+			if exiterr, ok := err.(*exec.ExitError); ok {
+				return CommandResult{
+					StdOut:          stdout,
+					StdErr:          stderr,
+					StdCombined:     stdcombined,
+					ExitCode:        exiterr.ExitCode(),
+					CommandTimedOut: false,
+				}, nil
+			} else if err != nil {
+				return CommandResult{}, err
+			} else {
+				return CommandResult{
+					StdOut:          stdout,
+					StdErr:          stderr,
+					StdCombined:     stdcombined,
+					ExitCode:        0,
+					CommandTimedOut: false,
+				}, nil
+			}
+
+		}
+
+	} else {
+
+		select {
+
+		case err := <-errch:
+			if exiterr, ok := err.(*exec.ExitError); ok {
+				return CommandResult{
+					StdOut:          stdout,
+					StdErr:          stderr,
+					StdCombined:     stdcombined,
+					ExitCode:        exiterr.ExitCode(),
+					CommandTimedOut: false,
+				}, nil
+			} else if err != nil {
+				return CommandResult{}, err
+			} else {
+				return CommandResult{
+					StdOut:          stdout,
+					StdErr:          stderr,
+					StdCombined:     stdcombined,
+					ExitCode:        0,
+					CommandTimedOut: false,
+				}, nil
+			}
+
+		}
+	}
+}

confext/confParser.go

@@ -0,0 +1,136 @@
+package confext
+
+import (
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"math/bits"
+	"os"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// ApplyEnvOverrides overrides field values from environment variables
+//
+// fields must be tagged with `env:"env_key"`
+func ApplyEnvOverrides[T any](c *T) error {
+
+	rval := reflect.ValueOf(c).Elem()
+	rtyp := rval.Type()
+
+	for i := 0; i < rtyp.NumField(); i++ {
+
+		rsfield := rtyp.Field(i)
+		rvfield := rval.Field(i)
+
+		envkey := rsfield.Tag.Get("env")
+		if envkey == "" {
+			continue
+		}
+
+		envval, efound := os.LookupEnv(envkey)
+		if !efound {
+			continue
+		}
+
+		if rvfield.Type() == reflect.TypeOf("") {
+
+			rvfield.Set(reflect.ValueOf(envval))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int64(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 64)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int64 (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int64(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int32(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 32)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int32(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int8(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int8(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(time.Duration(0)) {
+
+			dur, err := timeext.ParseDurationShortString(envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to duration (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(dur))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, dur.String())
+
+		} else if rvfield.Type() == reflect.TypeOf(time.UnixMilli(0)) {
+
+			tim, err := time.Parse(time.RFC3339Nano, envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to time.time (value := '%s')", envkey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(tim))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", envkey, tim.String())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf(int(0))) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,int> (value := '%s')", rvfield.Type().Name(), envkey, envval))
+			}
+
+			envcvl := reflect.ValueOf(envint).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", envkey, envcvl.Interface())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf("")) {
+
+			envcvl := reflect.ValueOf(envval).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", envkey, envcvl.Interface())
+
+		} else {
+			return errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvfield.Kind().String(), rvfield.Type().String()))
+		}
+	}
+
+	return nil
+}

confext/confParser_test.go

@@ -0,0 +1,116 @@
+package confext
+
+import (
+	"testing"
+	"time"
+)
+
+func TestApplyEnvOverridesNoop(t *testing.T) {
+
+	type aliasint int
+	type aliasstring string
+
+	type testdata struct {
+		V1 int           `env:"TEST_V1"`
+		VX string        ``
+		V2 string        `env:"TEST_V2"`
+		V3 int8          `env:"TEST_V3"`
+		V4 int32         `env:"TEST_V4"`
+		V5 int64         `env:"TEST_V5"`
+		V6 aliasint      `env:"TEST_V6"`
+		VY aliasint      ``
+		V7 aliasstring   `env:"TEST_V7"`
+		V8 time.Duration `env:"TEST_V8"`
+		V9 time.Time     `env:"TEST_V9"`
+	}
+
+	input := testdata{
+		V1: 1,
+		VX: "X",
+		V2: "2",
+		V3: 3,
+		V4: 4,
+		V5: 5,
+		V6: 6,
+		VY: 99,
+		V7: "7",
+		V8: 9,
+		V9: time.Unix(1671102873, 0),
+	}
+
+	output := input
+
+	err := ApplyEnvOverrides(&output)
+	if err != nil {
+		t.Errorf("%v", err)
+		t.FailNow()
+	}
+
+	assertEqual(t, input, output)
+}
+
+func TestApplyEnvOverridesSimple(t *testing.T) {
+
+	type aliasint int
+	type aliasstring string
+
+	type testdata struct {
+		V1 int           `env:"TEST_V1"`
+		VX string        ``
+		V2 string        `env:"TEST_V2"`
+		V3 int8          `env:"TEST_V3"`
+		V4 int32         `env:"TEST_V4"`
+		V5 int64         `env:"TEST_V5"`
+		V6 aliasint      `env:"TEST_V6"`
+		VY aliasint      ``
+		V7 aliasstring   `env:"TEST_V7"`
+		V8 time.Duration `env:"TEST_V8"`
+		V9 time.Time     `env:"TEST_V9"`
+	}
+
+	data := testdata{
+		V1: 1,
+		VX: "X",
+		V2: "2",
+		V3: 3,
+		V4: 4,
+		V5: 5,
+		V6: 6,
+		VY: 99,
+		V7: "7",
+		V8: 9,
+		V9: time.Unix(1671102873, 0),
+	}
+
+	t.Setenv("TEST_V1", "846")
+	t.Setenv("TEST_V2", "hello_world")
+	t.Setenv("TEST_V3", "6")
+	t.Setenv("TEST_V4", "333")
+	t.Setenv("TEST_V5", "-937")
+	t.Setenv("TEST_V6", "070")
+	t.Setenv("TEST_V7", "AAAAAA")
+	t.Setenv("TEST_V8", "1min4s")
+	t.Setenv("TEST_V9", "2009-11-10T23:00:00Z")
+
+	err := ApplyEnvOverrides(&data)
+	if err != nil {
+		t.Errorf("%v", err)
+		t.FailNow()
+	}
+
+	assertEqual(t, data.V1, 846)
+	assertEqual(t, data.V2, "hello_world")
+	assertEqual(t, data.V3, 6)
+	assertEqual(t, data.V4, 333)
+	assertEqual(t, data.V5, -937)
+	assertEqual(t, data.V6, 70)
+	assertEqual(t, data.V7, "AAAAAA")
+	assertEqual(t, data.V8, time.Second*64)
+	assertEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
+}
+
+func assertEqual[T comparable](t *testing.T, actual T, expected T) {
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
+}

cryptext/passHash.go

@@ -0,0 +1,336 @@
+package cryptext
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
+	"golang.org/x/crypto/bcrypt"
+	"strconv"
+	"strings"
+)
+
+const LatestPassHashVersion = 4
+
+// PassHash
+// - [v0]: plaintext password ( `0|...` )
+// - [v1]: sha256(plaintext)
+// - [v2]: seed | sha256<seed>(plaintext)
+// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]
+// - [v4]: bcrypt(plaintext) | [hex(totp)]
+type PassHash string
+
+func (ph PassHash) Valid() bool {
+	_, _, _, _, _, valid := ph.Data()
+	return valid
+}
+
+func (ph PassHash) HasTOTP() bool {
+	_, _, _, otp, _, _ := ph.Data()
+	return otp
+}
+
+func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bool, _totpsecret []byte, _valid bool) {
+
+	split := strings.Split(string(ph), "|")
+	if len(split) == 0 {
+		return -1, nil, nil, false, nil, false
+	}
+
+	version, err := strconv.ParseInt(split[0], 10, 32)
+	if err != nil {
+		return -1, nil, nil, false, nil, false
+	}
+
+	if version == 0 {
+		if len(split) != 2 {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), nil, []byte(split[1]), false, nil, true
+	}
+
+	if version == 1 {
+		if len(split) != 2 {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), nil, payload, false, nil, true
+	}
+
+	//
+	if version == 2 {
+		if len(split) != 3 {
+			return -1, nil, nil, false, nil, false
+		}
+		seed, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[2])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), seed, payload, false, nil, true
+	}
+
+	if version == 3 {
+		if len(split) != 4 {
+			return -1, nil, nil, false, nil, false
+		}
+		seed, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[2])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		totp := false
+		totpsecret := make([]byte, 0)
+		if split[3] != "0" {
+			totpsecret, err = hex.DecodeString(split[3])
+			totp = true
+		}
+		return int(version), seed, payload, totp, totpsecret, true
+	}
+
+	if version == 4 {
+		if len(split) != 3 {
+			return -1, nil, nil, false, nil, false
+		}
+		payload := []byte(split[1])
+		totp := false
+		totpsecret := make([]byte, 0)
+		if split[2] != "0" {
+			totpsecret, err = hex.DecodeString(split[3])
+			totp = true
+		}
+		return int(version), nil, payload, totp, totpsecret, true
+	}
+
+	return -1, nil, nil, false, nil, false
+}
+
+func (ph PassHash) Verify(plainpass string, totp *string) bool {
+	version, seed, payload, hastotp, totpsecret, valid := ph.Data()
+	if !valid {
+		return false
+	}
+
+	if hastotp && totp == nil {
+		return false
+	}
+
+	if version == 0 {
+		return langext.ArrEqualsExact([]byte(plainpass), payload)
+	}
+
+	if version == 1 {
+		return langext.ArrEqualsExact(hash256(plainpass), payload)
+	}
+
+	if version == 2 {
+		return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload)
+	}
+
+	if version == 3 {
+		if !hastotp {
+			return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload)
+		} else {
+			return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload) && totpext.Validate(totpsecret, *totp)
+		}
+	}
+
+	if version == 4 {
+		if !hastotp {
+			return bcrypt.CompareHashAndPassword(payload, []byte(plainpass)) == nil
+		} else {
+			return bcrypt.CompareHashAndPassword(payload, []byte(plainpass)) == nil && totpext.Validate(totpsecret, *totp)
+		}
+	}
+
+	return false
+}
+
+func (ph PassHash) NeedsPasswordUpgrade() bool {
+	version, _, _, _, _, valid := ph.Data()
+	return valid && version < LatestPassHashVersion
+}
+
+func (ph PassHash) Upgrade(plainpass string) (PassHash, error) {
+	version, _, _, hastotp, totpsecret, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid password")
+	}
+	if version == LatestPassHashVersion {
+		return ph, nil
+	}
+	if hastotp {
+		return HashPassword(plainpass, totpsecret)
+	} else {
+		return HashPassword(plainpass, nil)
+	}
+}
+
+func (ph PassHash) ClearTOTP() (PassHash, error) {
+	version, _, _, _, _, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid PassHash")
+	}
+
+	if version == 0 {
+		return ph, nil
+	}
+
+	if version == 1 {
+		return ph, nil
+	}
+
+	if version == 2 {
+		return ph, nil
+	}
+
+	if version == 3 {
+		split := strings.Split(string(ph), "|")
+		split[3] = "0"
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	if version == 4 {
+		split := strings.Split(string(ph), "|")
+		split[2] = "0"
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	return "", errors.New("unknown version")
+}
+
+func (ph PassHash) WithTOTP(totpSecret []byte) (PassHash, error) {
+	version, _, _, _, _, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid PassHash")
+	}
+
+	if version == 0 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 1 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 2 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 3 {
+		split := strings.Split(string(ph), "|")
+		split[3] = hex.EncodeToString(totpSecret)
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	if version == 4 {
+		split := strings.Split(string(ph), "|")
+		split[2] = hex.EncodeToString(totpSecret)
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	return "", errors.New("unknown version")
+}
+
+func (ph PassHash) String() string {
+	return string(ph)
+}
+
+func HashPassword(plainpass string, totpSecret []byte) (PassHash, error) {
+	return HashPasswordV4(plainpass, totpSecret)
+}
+
+func HashPasswordV4(plainpass string, totpSecret []byte) (PassHash, error) {
+	var strtotp string
+
+	if totpSecret == nil {
+		strtotp = "0"
+	} else {
+		strtotp = hex.EncodeToString(totpSecret)
+	}
+
+	payload, err := bcrypt.GenerateFromPassword([]byte(plainpass), bcrypt.MinCost)
+	if err != nil {
+		return "", err
+	}
+
+	return PassHash(fmt.Sprintf("4|%s|%s", string(payload), strtotp)), nil
+}
+
+func HashPasswordV3(plainpass string, totpSecret []byte) (PassHash, error) {
+	var strtotp string
+
+	if totpSecret == nil {
+		strtotp = "0"
+	} else {
+		strtotp = hex.EncodeToString(totpSecret)
+	}
+
+	seed, err := newSeed()
+	if err != nil {
+		return "", err
+	}
+
+	checksum := hash256Seeded(plainpass, seed)
+
+	return PassHash(fmt.Sprintf("3|%s|%s|%s",
+		base64.RawStdEncoding.EncodeToString(seed),
+		base64.RawStdEncoding.EncodeToString(checksum),
+		strtotp)), nil
+}
+
+func HashPasswordV2(plainpass string) (PassHash, error) {
+	seed, err := newSeed()
+	if err != nil {
+		return "", err
+	}
+
+	checksum := hash256Seeded(plainpass, seed)
+
+	return PassHash(fmt.Sprintf("2|%s|%s", base64.RawStdEncoding.EncodeToString(seed), base64.RawStdEncoding.EncodeToString(checksum))), nil
+}
+
+func HashPasswordV1(plainpass string) (PassHash, error) {
+	return PassHash(fmt.Sprintf("1|%s", base64.RawStdEncoding.EncodeToString(hash256(plainpass)))), nil
+}
+
+func HashPasswordV0(plainpass string) (PassHash, error) {
+	return PassHash(fmt.Sprintf("0|%s", plainpass)), nil
+}
+
+func hash256(s string) []byte {
+	h := sha256.New()
+	h.Write([]byte(s))
+	bs := h.Sum(nil)
+	return bs
+}
+
+func hash256Seeded(s string, seed []byte) []byte {
+	h := sha256.New()
+	h.Write(seed)
+	h.Write([]byte(s))
+	bs := h.Sum(nil)
+	return bs
+}
+
+func newSeed() ([]byte, error) {
+	secret := make([]byte, 32)
+	_, err := rand.Read(secret)
+	if err != nil {
+		return nil, err
+	}
+	return secret, nil
+}

dataext/bufferedReadCloser.go

@@ -1,56 +1,157 @@
 package dataext
 
-import "io"
+import (
+	"errors"
+	"io"
+)
+
+type brcMode int
+
+const (
+	modeSourceReading  brcMode = 0
+	modeSourceFinished brcMode = 1
+	modeBufferReading  brcMode = 2
+	modeBufferFinished brcMode = 3
+)
 
 type BufferedReadCloser interface {
 	io.ReadCloser
 	BufferedAll() ([]byte, error)
+	Reset() error
 }
 
 type bufferedReadCloser struct {
-	buffer   []byte
-	inner    io.ReadCloser
-	finished bool
-}
-
-func (b *bufferedReadCloser) Read(p []byte) (int, error) {
-
-	n, err := b.inner.Read(p)
-	if n > 0 {
-		b.buffer = append(b.buffer, p[0:n]...)
-	}
-
-	if err == io.EOF {
-		b.finished = true
-	}
-
-	return n, err
+	buffer []byte
+	inner  io.ReadCloser
+	mode   brcMode
+	off    int
 }
 
 func NewBufferedReadCloser(sub io.ReadCloser) BufferedReadCloser {
 	return &bufferedReadCloser{
-		buffer:   make([]byte, 0, 1024),
-		inner:    sub,
-		finished: false,
+		buffer: make([]byte, 0, 1024),
+		inner:  sub,
+		mode:   modeSourceReading,
+		off:    0,
+	}
+}
+
+func (b *bufferedReadCloser) Read(p []byte) (int, error) {
+	switch b.mode {
+	case modeSourceReading:
+		n, err := b.inner.Read(p)
+		if n > 0 {
+			b.buffer = append(b.buffer, p[0:n]...)
+		}
+
+		if err == io.EOF {
+			b.mode = modeSourceFinished
+		}
+
+		return n, err
+
+	case modeSourceFinished:
+		return 0, io.EOF
+
+	case modeBufferReading:
+
+		if len(b.buffer) <= b.off {
+			b.mode = modeBufferFinished
+			if len(p) == 0 {
+				return 0, nil
+			}
+			return 0, io.EOF
+		}
+
+		n := copy(p, b.buffer[b.off:])
+		b.off += n
+		return n, nil
+
+	case modeBufferFinished:
+		return 0, io.EOF
+
+	default:
+		return 0, errors.New("object in undefined status")
 	}
 }
 
 func (b *bufferedReadCloser) Close() error {
-	err := b.inner.Close()
-	if err != nil {
-		b.finished = true
+	switch b.mode {
+	case modeSourceReading:
+		_, err := b.BufferedAll()
+		if err != nil {
+			return err
+		}
+		err = b.inner.Close()
+		if err != nil {
+			return err
+		}
+		b.mode = modeSourceFinished
+		return nil
+
+	case modeSourceFinished:
+		return nil
+
+	case modeBufferReading:
+		b.mode = modeBufferFinished
+		return nil
+
+	case modeBufferFinished:
+		return nil
+
+	default:
+		return errors.New("object in undefined status")
 	}
-	return err
+
 }
 
 func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
-	arr := make([]byte, 1024)
-	for !b.finished {
-		_, err := b.Read(arr)
-		if err != nil && err != io.EOF {
-			return nil, err
+	switch b.mode {
+	case modeSourceReading:
+		arr := make([]byte, 1024)
+		for b.mode == modeSourceReading {
+			_, err := b.Read(arr)
+			if err != nil && err != io.EOF {
+				return nil, err
+			}
 		}
-	}
+		return b.buffer, nil
 
-	return b.buffer, nil
+	case modeSourceFinished:
+		return b.buffer, nil
+
+	case modeBufferReading:
+		return b.buffer, nil
+
+	case modeBufferFinished:
+		return b.buffer, nil
+
+	default:
+		return nil, errors.New("object in undefined status")
+	}
+}
+
+func (b *bufferedReadCloser) Reset() error {
+	switch b.mode {
+	case modeSourceReading:
+		fallthrough
+	case modeSourceFinished:
+		err := b.Close()
+		if err != nil {
+			return err
+		}
+		b.mode = modeBufferReading
+		b.off = 0
+		return nil
+
+	case modeBufferReading:
+		fallthrough
+	case modeBufferFinished:
+		b.mode = modeBufferReading
+		b.off = 0
+		return nil
+
+	default:
+		return errors.New("object in undefined status")
+	}
 }

dataext/lruMap.go

@@ -19,40 +19,38 @@ import (
 // There are also a bunch of unit tests to ensure that the cache is always in a consistent state
 //
 
-type LRUData interface{}
-
-type LRUMap struct {
+type LRUMap[TData any] struct {
 	maxsize int
 	lock    sync.Mutex
 
-	cache map[string]*cacheNode
+	cache map[string]*cacheNode[TData]
 
-	lfuHead *cacheNode
-	lfuTail *cacheNode
+	lfuHead *cacheNode[TData]
+	lfuTail *cacheNode[TData]
 }
 
-type cacheNode struct {
+type cacheNode[TData any] struct {
 	key    string
-	data   LRUData
-	parent *cacheNode
-	child  *cacheNode
+	data   TData
+	parent *cacheNode[TData]
+	child  *cacheNode[TData]
 }
 
-func NewLRUMap(size int) *LRUMap {
+func NewLRUMap[TData any](size int) *LRUMap[TData] {
 	if size <= 2 && size != 0 {
 		panic("Size must be > 2  (or 0)")
 	}
 
-	return &LRUMap{
+	return &LRUMap[TData]{
 		maxsize: size,
 		lock:    sync.Mutex{},
-		cache:   make(map[string]*cacheNode, size+1),
+		cache:   make(map[string]*cacheNode[TData], size+1),
 		lfuHead: nil,
 		lfuTail: nil,
 	}
 }
 
-func (c *LRUMap) Put(key string, value LRUData) {
+func (c *LRUMap[TData]) Put(key string, value TData) {
 	if c.maxsize == 0 {
 		return // cache disabled
 	}
@@ -70,7 +68,7 @@ func (c *LRUMap) Put(key string, value LRUData) {
 	}
 
 	// key does not exist: insert into map and add to top of LFU
-	node = &cacheNode{
+	node = &cacheNode[TData]{
 		key:    key,
 		data:   value,
 		parent: nil,
@@ -95,9 +93,9 @@ func (c *LRUMap) Put(key string, value LRUData) {
 	}
 }
 
-func (c *LRUMap) TryGet(key string) (LRUData, bool) {
+func (c *LRUMap[TData]) TryGet(key string) (TData, bool) {
 	if c.maxsize == 0 {
-		return nil, false // cache disabled
+		return *new(TData), false // cache disabled
 	}
 
 	c.lock.Lock()
@@ -105,13 +103,13 @@ func (c *LRUMap) TryGet(key string) (LRUData, bool) {
 
 	val, ok := c.cache[key]
 	if !ok {
-		return nil, false
+		return *new(TData), false
 	}
 	c.moveNodeToTop(val)
 	return val.data, ok
 }
 
-func (c *LRUMap) moveNodeToTop(node *cacheNode) {
+func (c *LRUMap[TData]) moveNodeToTop(node *cacheNode[TData]) {
 	// (only called in critical section !)
 
 	if c.lfuHead == node { // fast case
@@ -144,7 +142,7 @@ func (c *LRUMap) moveNodeToTop(node *cacheNode) {
 	}
 }
 
-func (c *LRUMap) Size() int {
+func (c *LRUMap[TData]) Size() int {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	return len(c.cache)

dataext/lruMap_test.go

@@ -12,7 +12,7 @@ func init() {
 }
 
 func TestResultCache1(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key := randomKey()
@@ -39,7 +39,7 @@ func TestResultCache1(t *testing.T) {
 	if !ok {
 		t.Errorf("cache TryGet returned no value")
 	}
-	if !eq(cacheval, val) {
+	if cacheval != val {
 		t.Errorf("cache TryGet returned different value (%+v <> %+v)", cacheval, val)
 	}
 
@@ -50,7 +50,7 @@ func TestResultCache1(t *testing.T) {
 }
 
 func TestResultCache2(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -150,7 +150,7 @@ func TestResultCache2(t *testing.T) {
 }
 
 func TestResultCache3(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -160,20 +160,20 @@ func TestResultCache3(t *testing.T) {
 	cache.Put(key1, val1)
 	verifyLRUList(cache, t)
 
-	if val, ok := cache.TryGet(key1); !ok || !eq(val, val1) {
+	if val, ok := cache.TryGet(key1); !ok || val != val1 {
 		t.Errorf("Value in cache should be [val1]")
 	}
 
 	cache.Put(key1, val2)
 	verifyLRUList(cache, t)
 
-	if val, ok := cache.TryGet(key1); !ok || !eq(val, val2) {
+	if val, ok := cache.TryGet(key1); !ok || val != val2 {
 		t.Errorf("Value in cache should be [val2]")
 	}
 }
 
 // does a basic consistency check over the internal cache representation
-func verifyLRUList(cache *LRUMap, t *testing.T) {
+func verifyLRUList[TData any](cache *LRUMap[TData], t *testing.T) {
 	size := 0
 
 	tailFound := false
@@ -250,23 +250,10 @@ func randomKey() string {
 	return strconv.FormatInt(rand.Int63(), 16)
 }
 
-func randomVal() LRUData {
+func randomVal() string {
 	v, err := langext.NewHexUUID()
 	if err != nil {
 		panic(err)
 	}
-	return &v
-}
-
-func eq(a LRUData, b LRUData) bool {
-	v1, ok1 := a.(*string)
-	v2, ok2 := b.(*string)
-	if ok1 && ok2 {
-		if v1 == nil || v2 == nil {
-			return false
-		}
-		return v1 == v2
-	}
-
-	return false
+	return v
 }

dataext/merge.go

@@ -0,0 +1,35 @@
+package dataext
+
+import (
+	"reflect"
+)
+
+func ObjectMerge[T1 any, T2 any](base T1, override T2) T1 {
+
+	reflBase := reflect.ValueOf(&base).Elem()
+	reflOvrd := reflect.ValueOf(&override).Elem()
+
+	for i := 0; i < reflBase.NumField(); i++ {
+
+		fieldBase := reflBase.Field(i)
+		fieldOvrd := reflOvrd.Field(i)
+
+		if fieldBase.Kind() != reflect.Ptr || fieldOvrd.Kind() != reflect.Ptr {
+			continue
+		}
+
+		kindBase := fieldBase.Type().Elem().Kind()
+		kindOvrd := fieldOvrd.Type().Elem().Kind()
+
+		if kindBase != kindOvrd {
+			continue
+		}
+
+		if !fieldOvrd.IsNil() {
+			fieldBase.Set(fieldOvrd.Elem().Addr())
+		}
+
+	}
+
+	return base
+}

dataext/merge_test.go

@@ -0,0 +1,70 @@
+package dataext
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"testing"
+)
+
+func TestObjectMerge(t *testing.T) {
+	type A struct {
+		Field1   *int
+		Field2   *string
+		Field3   *float64
+		Field4   *bool
+		OnlyA    int64
+		DiffType int
+	}
+	type B struct {
+		Field1   *int
+		Field2   *string
+		Field3   *float64
+		Field4   *bool
+		OnlyB    int64
+		DiffType string
+	}
+
+	valueA := A{
+		Field1:   nil,
+		Field2:   langext.Ptr("99"),
+		Field3:   langext.Ptr(12.2),
+		Field4:   nil,
+		OnlyA:    1,
+		DiffType: 2,
+	}
+
+	valueB := B{
+		Field1:   langext.Ptr(12),
+		Field2:   nil,
+		Field3:   langext.Ptr(13.2),
+		Field4:   nil,
+		OnlyB:    1,
+		DiffType: "X",
+	}
+
+	valueMerge := ObjectMerge(valueA, valueB)
+
+	assertPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1)
+	assertPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2)
+	assertPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3)
+	assertPtrEqual(t, "Field4", valueMerge.Field4, nil)
+
+}
+
+func assertPtrEqual[T1 comparable](t *testing.T, ident string, actual *T1, expected *T1) {
+	if actual == nil && expected == nil {
+		return
+	}
+	if actual != nil && expected != nil {
+		if *actual != *expected {
+			t.Errorf("[%s] values differ: Actual: '%v', Expected: '%v'", ident, *actual, *expected)
+		} else {
+			return
+		}
+	}
+	if actual == nil && expected != nil {
+		t.Errorf("[%s] values differ: Actual: nil, Expected: not-nil", ident)
+	}
+	if actual != nil && expected == nil {
+		t.Errorf("[%s] values differ: Actual: not-nil, Expected: nil", ident)
+	}
+}

dataext/structHash.go

@@ -0,0 +1,254 @@
+package dataext
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"hash"
+	"io"
+	"reflect"
+	"sort"
+)
+
+type StructHashOptions struct {
+	HashAlgo    hash.Hash
+	Tag         *string
+	SkipChannel bool
+	SkipFunc    bool
+}
+
+func StructHash(dat any, opt ...StructHashOptions) (r []byte, err error) {
+	defer func() {
+		if rec := recover(); rec != nil {
+			r = nil
+			err = errors.New(fmt.Sprintf("recovered panic: %v", rec))
+		}
+	}()
+
+	shopt := StructHashOptions{}
+	if len(opt) > 1 {
+		return nil, errors.New("multiple options supplied")
+	} else if len(opt) == 1 {
+		shopt = opt[0]
+	}
+
+	if shopt.HashAlgo == nil {
+		shopt.HashAlgo = sha256.New()
+	}
+
+	writer := new(bytes.Buffer)
+
+	if langext.IsNil(dat) {
+		shopt.HashAlgo.Reset()
+		shopt.HashAlgo.Write(writer.Bytes())
+		res := shopt.HashAlgo.Sum(nil)
+		return res, nil
+	}
+
+	err = binarize(writer, reflect.ValueOf(dat), shopt)
+	if err != nil {
+		return nil, err
+	}
+
+	shopt.HashAlgo.Reset()
+	shopt.HashAlgo.Write(writer.Bytes())
+	res := shopt.HashAlgo.Sum(nil)
+
+	return res, nil
+}
+
+func writeBinarized(writer io.Writer, dat any) error {
+	tmp := bytes.Buffer{}
+	err := binary.Write(&tmp, binary.LittleEndian, dat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(writer, binary.LittleEndian, uint64(tmp.Len()))
+	if err != nil {
+		return err
+	}
+	_, err = writer.Write(tmp.Bytes())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func binarize(writer io.Writer, dat reflect.Value, opt StructHashOptions) error {
+	var err error
+
+	err = binary.Write(writer, binary.LittleEndian, uint8(dat.Kind()))
+	switch dat.Kind() {
+	case reflect.Ptr, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice, reflect.Interface:
+		if dat.IsNil() {
+			err = binary.Write(writer, binary.LittleEndian, uint64(0))
+			if err != nil {
+				return err
+			}
+			return nil
+		}
+	}
+
+	err = binary.Write(writer, binary.LittleEndian, uint64(len(dat.Type().String())))
+	if err != nil {
+		return err
+	}
+	_, err = writer.Write([]byte(dat.Type().String()))
+	if err != nil {
+		return err
+	}
+
+	switch dat.Type().Kind() {
+	case reflect.Invalid:
+		return errors.New("cannot binarize value of kind <Invalid>")
+	case reflect.Bool:
+		return writeBinarized(writer, dat.Bool())
+	case reflect.Int:
+		return writeBinarized(writer, int64(dat.Int()))
+	case reflect.Int8:
+		fallthrough
+	case reflect.Int16:
+		fallthrough
+	case reflect.Int32:
+		fallthrough
+	case reflect.Int64:
+		return writeBinarized(writer, dat.Interface())
+	case reflect.Uint:
+		return writeBinarized(writer, uint64(dat.Int()))
+	case reflect.Uint8:
+		fallthrough
+	case reflect.Uint16:
+		fallthrough
+	case reflect.Uint32:
+		fallthrough
+	case reflect.Uint64:
+		return writeBinarized(writer, dat.Interface())
+	case reflect.Uintptr:
+		return errors.New("cannot binarize value of kind <Uintptr>")
+	case reflect.Float32:
+		fallthrough
+	case reflect.Float64:
+		return writeBinarized(writer, dat.Interface())
+	case reflect.Complex64:
+		return errors.New("cannot binarize value of kind <Complex64>")
+	case reflect.Complex128:
+		return errors.New("cannot binarize value of kind <Complex128>")
+	case reflect.Slice:
+		fallthrough
+	case reflect.Array:
+		return binarizeArrayOrSlice(writer, dat, opt)
+	case reflect.Chan:
+		if opt.SkipChannel {
+			return nil
+		}
+		return errors.New("cannot binarize value of kind <Chan>")
+	case reflect.Func:
+		if opt.SkipFunc {
+			return nil
+		}
+		return errors.New("cannot binarize value of kind <Func>")
+	case reflect.Interface:
+		return binarize(writer, dat.Elem(), opt)
+	case reflect.Map:
+		return binarizeMap(writer, dat, opt)
+	case reflect.Pointer:
+		return binarize(writer, dat.Elem(), opt)
+	case reflect.String:
+		v := dat.String()
+		err = binary.Write(writer, binary.LittleEndian, uint64(len(v)))
+		if err != nil {
+			return err
+		}
+		_, err = writer.Write([]byte(v))
+		if err != nil {
+			return err
+		}
+		return nil
+	case reflect.Struct:
+		return binarizeStruct(writer, dat, opt)
+	case reflect.UnsafePointer:
+		return errors.New("cannot binarize value of kind <UnsafePointer>")
+	default:
+		return errors.New("cannot binarize value of unknown kind <" + dat.Type().Kind().String() + ">")
+	}
+}
+
+func binarizeStruct(writer io.Writer, dat reflect.Value, opt StructHashOptions) error {
+	err := binary.Write(writer, binary.LittleEndian, uint64(dat.NumField()))
+	if err != nil {
+		return err
+	}
+
+	for i := 0; i < dat.NumField(); i++ {
+
+		if opt.Tag != nil {
+			if _, ok := dat.Type().Field(i).Tag.Lookup(*opt.Tag); !ok {
+				continue
+			}
+		}
+
+		err = binary.Write(writer, binary.LittleEndian, uint64(len(dat.Type().Field(i).Name)))
+		if err != nil {
+			return err
+		}
+		_, err = writer.Write([]byte(dat.Type().Field(i).Name))
+		if err != nil {
+			return err
+		}
+
+		err = binarize(writer, dat.Field(i), opt)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func binarizeArrayOrSlice(writer io.Writer, dat reflect.Value, opt StructHashOptions) error {
+	err := binary.Write(writer, binary.LittleEndian, uint64(dat.Len()))
+	if err != nil {
+		return err
+	}
+
+	for i := 0; i < dat.Len(); i++ {
+		err := binarize(writer, dat.Index(i), opt)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func binarizeMap(writer io.Writer, dat reflect.Value, opt StructHashOptions) error {
+	err := binary.Write(writer, binary.LittleEndian, uint64(dat.Len()))
+	if err != nil {
+		return err
+	}
+
+	sub := make([][]byte, 0, dat.Len())
+
+	for _, k := range dat.MapKeys() {
+		tmp := bytes.Buffer{}
+		err = binarize(&tmp, dat.MapIndex(k), opt)
+		if err != nil {
+			return err
+		}
+		sub = append(sub, tmp.Bytes())
+	}
+
+	sort.Slice(sub, func(i1, i2 int) bool { return bytes.Compare(sub[i1], sub[i2]) < 0 })
+
+	for _, v := range sub {
+		_, err = writer.Write(v)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

dataext/structHash_test.go

@@ -0,0 +1,143 @@
+package dataext
+
+import (
+	"encoding/hex"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"testing"
+)
+
+func noErrStructHash(t *testing.T, dat any, opt ...StructHashOptions) []byte {
+	res, err := StructHash(dat, opt...)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+		return nil
+	}
+	return res
+}
+
+func TestStructHashSimple(t *testing.T) {
+
+	assertEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello"))
+	assertEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0))
+	assertEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{}))
+	assertEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{}))
+	assertEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3}))
+	assertEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil))
+	assertEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil}))
+	assertEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{}))
+
+}
+
+func TestStructHashSimpleStruct(t *testing.T) {
+
+	type t0 struct {
+		F1 int
+		F2 []string
+		F3 *int
+	}
+
+	assertEqual(t, "a90bff751c70c738bb5cfc9b108e783fa9c19c0bc9273458e0aaee6e74aa1b92", noErrStructHash(t, t0{
+		F1: 10,
+		F2: []string{"1", "2", "3"},
+		F3: nil,
+	}))
+
+	assertEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{
+		F1: 10,
+		F2: []string{"1", "2", "3"},
+		F3: langext.Ptr(99),
+	}))
+
+}
+
+func TestStructHashLayeredStruct(t *testing.T) {
+
+	type t1_1 struct {
+		F10 float32
+		F12 float64
+		F15 bool
+	}
+	type t1_2 struct {
+		SV1 *t1_1
+		SV2 *t1_1
+		SV3 t1_1
+	}
+
+	assertEqual(t, "fd4ca071fb40a288fee4b7a3dfdaab577b30cb8f80f81ec511e7afd72dc3b469", noErrStructHash(t, t1_2{
+		SV1: nil,
+		SV2: nil,
+		SV3: t1_1{
+			F10: 1,
+			F12: 2,
+			F15: false,
+		},
+	}))
+	assertEqual(t, "3fbf7c67d8121deda075cc86319a4e32d71744feb2cebf89b43bc682f072a029", noErrStructHash(t, t1_2{
+		SV1: nil,
+		SV2: &t1_1{},
+		SV3: t1_1{
+			F10: 3,
+			F12: 4,
+			F15: true,
+		},
+	}))
+	assertEqual(t, "b1791ccd1b346c3ede5bbffda85555adcd8216b93ffca23f14fe175ec47c5104", noErrStructHash(t, t1_2{
+		SV1: &t1_1{},
+		SV2: &t1_1{},
+		SV3: t1_1{
+			F10: 5,
+			F12: 6,
+			F15: false,
+		},
+	}))
+
+}
+
+func TestStructHashMap(t *testing.T) {
+
+	type t0 struct {
+		F1 int
+		F2 map[string]int
+	}
+
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+		F1: 10,
+		F2: map[string]int{
+			"x": 1,
+			"0": 2,
+			"a": 99,
+		},
+	}))
+
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+		F1: 10,
+		F2: map[string]int{
+			"a": 99,
+			"x": 1,
+			"0": 2,
+		},
+	}))
+
+	m3 := make(map[string]int, 99)
+	m3["a"] = 0
+	m3["x"] = 0
+	m3["0"] = 0
+
+	m3["0"] = 99
+	m3["x"] = 1
+	m3["a"] = 2
+
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+		F1: 10,
+		F2: m3,
+	}))
+
+}
+
+func assertEqual(t *testing.T, expected string, actual []byte) {
+	actualStr := hex.EncodeToString(actual)
+	if actualStr != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actualStr, expected)
+	}
+}

dataext/syncSet.go

@@ -2,17 +2,17 @@ package dataext
 
 import "sync"
 
-type SyncStringSet struct {
-	data map[string]bool
+type SyncSet[TData comparable] struct {
+	data map[TData]bool
 	lock sync.Mutex
 }
 
-func (s *SyncStringSet) Add(value string) bool {
+func (s *SyncSet[TData]) Add(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	_, ok := s.data[value]
@@ -21,12 +21,12 @@ func (s *SyncStringSet) Add(value string) bool {
 	return !ok
 }
 
-func (s *SyncStringSet) AddAll(values []string) {
+func (s *SyncSet[TData]) AddAll(values []TData) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	for _, value := range values {
@@ -34,12 +34,12 @@ func (s *SyncStringSet) AddAll(values []string) {
 	}
 }
 
-func (s *SyncStringSet) Contains(value string) bool {
+func (s *SyncSet[TData]) Contains(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	_, ok := s.data[value]
@@ -47,15 +47,15 @@ func (s *SyncStringSet) Contains(value string) bool {
 	return ok
 }
 
-func (s *SyncStringSet) Get() []string {
+func (s *SyncSet[TData]) Get() []TData {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
-	r := make([]string, 0, len(s.data))
+	r := make([]TData, 0, len(s.data))
 
 	for k := range s.data {
 		r = append(r, k)

go.mod

@@ -3,6 +3,11 @@ module gogs.mikescher.com/BlackForestBytes/goext
 go 1.19
 
 require (
-	golang.org/x/sys v0.1.0
-	golang.org/x/term v0.1.0
+	golang.org/x/sys v0.3.0
+	golang.org/x/term v0.3.0
+)
+
+require (
+	github.com/jmoiron/sqlx v1.3.5 // indirect
+	golang.org/x/crypto v0.4.0 // indirect
 )

go.sum

@@ -1,4 +1,15 @@
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
+github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
+github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
+golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
 golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.1.0 h1:g6Z6vPFA9dYBAF7DWcH6sCcOntplXsDKcliusYijMlw=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=

langext/array.go

@@ -70,7 +70,73 @@ func ArrEqualsExact[T comparable](arr1 []T, arr2 []T) bool {
 	return true
 }
 
-func ArrAll(arr interface{}, fn func(int) bool) bool {
+func ArrAll[T any](arr []T, fn func(T) bool) bool {
+	for _, av := range arr {
+		if !fn(av) {
+			return false
+		}
+	}
+	return true
+}
+
+func ArrAllErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
+	for _, av := range arr {
+		v, err := fn(av)
+		if err != nil {
+			return false, err
+		}
+		if !v {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func ArrNone[T any](arr []T, fn func(T) bool) bool {
+	for _, av := range arr {
+		if fn(av) {
+			return false
+		}
+	}
+	return true
+}
+
+func ArrNoneErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
+	for _, av := range arr {
+		v, err := fn(av)
+		if err != nil {
+			return false, err
+		}
+		if v {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func ArrAny[T any](arr []T, fn func(T) bool) bool {
+	for _, av := range arr {
+		if fn(av) {
+			return true
+		}
+	}
+	return false
+}
+
+func ArrAnyErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
+	for _, av := range arr {
+		v, err := fn(av)
+		if err != nil {
+			return false, err
+		}
+		if v {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func ArrIdxAll(arr any, fn func(int) bool) bool {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		if !fn(i) {
@@ -80,7 +146,7 @@ func ArrAll(arr interface{}, fn func(int) bool) bool {
 	return true
 }
 
-func ArrAllErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+func ArrIdxAllErr(arr any, fn func(int) (bool, error)) (bool, error) {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		v, err := fn(i)
@@ -94,7 +160,7 @@ func ArrAllErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
 	return true, nil
 }
 
-func ArrNone(arr interface{}, fn func(int) bool) bool {
+func ArrIdxNone(arr any, fn func(int) bool) bool {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		if fn(i) {
@@ -104,7 +170,7 @@ func ArrNone(arr interface{}, fn func(int) bool) bool {
 	return true
 }
 
-func ArrNoneErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+func ArrIdxNoneErr(arr any, fn func(int) (bool, error)) (bool, error) {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		v, err := fn(i)
@@ -118,7 +184,7 @@ func ArrNoneErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
 	return true, nil
 }
 
-func ArrAny(arr interface{}, fn func(int) bool) bool {
+func ArrIdxAny(arr any, fn func(int) bool) bool {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		if fn(i) {
@@ -128,7 +194,7 @@ func ArrAny(arr interface{}, fn func(int) bool) bool {
 	return false
 }
 
-func ArrAnyErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+func ArrIdxAnyErr(arr any, fn func(int) (bool, error)) (bool, error) {
 	av := reflect.ValueOf(arr)
 	for i := 0; i < av.Len(); i++ {
 		v, err := fn(i)
@@ -142,7 +208,7 @@ func ArrAnyErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
 	return false, nil
 }
 
-func ArrFirst[T comparable](arr []T, comp func(v T) bool) (T, bool) {
+func ArrFirst[T any](arr []T, comp func(v T) bool) (T, bool) {
 	for _, v := range arr {
 		if comp(v) {
 			return v, true
@@ -151,7 +217,7 @@ func ArrFirst[T comparable](arr []T, comp func(v T) bool) (T, bool) {
 	return *new(T), false
 }
 
-func ArrLast[T comparable](arr []T, comp func(v T) bool) (T, bool) {
+func ArrLast[T any](arr []T, comp func(v T) bool) (T, bool) {
 	found := false
 	result := *new(T)
 	for _, v := range arr {
@@ -163,6 +229,25 @@ func ArrLast[T comparable](arr []T, comp func(v T) bool) (T, bool) {
 	return result, found
 }
 
+func ArrFirstIndex[T comparable](arr []T, needle T) int {
+	for i, v := range arr {
+		if v == needle {
+			return i
+		}
+	}
+	return -1
+}
+
+func ArrLastIndex[T comparable](arr []T, needle T) int {
+	result := -1
+	for i, v := range arr {
+		if v == needle {
+			result = i
+		}
+	}
+	return result
+}
+
 func AddToSet[T comparable](set []T, add T) []T {
 	for _, v := range set {
 		if v == add {
@@ -171,3 +256,19 @@ func AddToSet[T comparable](set []T, add T) []T {
 	}
 	return append(set, add)
 }
+
+func ArrMap[T1 any, T2 any](arr []T1, conv func(v T1) T2) []T2 {
+	r := make([]T2, len(arr))
+	for i, v := range arr {
+		r[i] = conv(v)
+	}
+	return r
+}
+
+func ArrSum[T NumberConstraint](arr []T) T {
+	var r T = 0
+	for _, v := range arr {
+		r += v
+	}
+	return r
+}

langext/bool.go

@@ -7,3 +7,11 @@ func FormatBool(v bool, strTrue string, strFalse string) string {
 		return strFalse
 	}
 }
+
+func Conditional[T any](v bool, resTrue T, resFalse T) T {
+	if v {
+		return resTrue
+	} else {
+		return resFalse
+	}
+}

langext/sort.go

@@ -0,0 +1,39 @@
+package langext
+
+import "sort"
+
+func Sort[T OrderedConstraint](arr []T) {
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func SortStable[T OrderedConstraint](arr []T) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func IsSorted[T OrderedConstraint](arr []T) bool {
+	return sort.SliceIsSorted(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func SortSlice[T any](arr []T, less func(v1, v2 T) bool) {
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}
+
+func SortSliceStable[T any](arr []T, less func(v1, v2 T) bool) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}
+
+func IsSliceSorted[T any](arr []T, less func(v1, v2 T) bool) bool {
+	return sort.SliceIsSorted(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}

langext/string.go

@@ -107,3 +107,11 @@ func NumToStringOpt[V IntConstraint](v *V, fallback string) string {
 		return fmt.Sprintf("%d", v)
 	}
 }
+
+func StrRepeat(val string, count int) string {
+	r := ""
+	for i := 0; i < count; i++ {
+		r += val
+	}
+	return r
+}

mathext/math.go

@@ -29,3 +29,21 @@ func Min[T langext.OrderedConstraint](v1 T, v2 T) T {
 		return v2
 	}
 }
+
+func Abs[T langext.NumberConstraint](v T) T {
+	if v < 0 {
+		return -v
+	} else {
+		return v
+	}
+}
+
+func Clamp[T langext.NumberConstraint](v T, min T, max T) T {
+	if v < min {
+		return min
+	} else if v > max {
+		return max
+	} else {
+		return v
+	}
+}

sq/database.go

@@ -0,0 +1,128 @@
+package sq
+
+import (
+	"context"
+	"database/sql"
+	"github.com/jmoiron/sqlx"
+	"sync"
+)
+
+type DB interface {
+	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
+	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
+	Ping(ctx context.Context) error
+	BeginTransaction(ctx context.Context, iso sql.IsolationLevel) (Tx, error)
+	AddListener(listener Listener)
+	Exit() error
+}
+
+type database struct {
+	db    *sqlx.DB
+	txctr uint16
+	lock  sync.Mutex
+	lstr  []Listener
+}
+
+func NewDB(db *sqlx.DB) DB {
+	return &database{
+		db:    db,
+		txctr: 0,
+		lock:  sync.Mutex{},
+		lstr:  make([]Listener, 0),
+	}
+}
+
+func (db *database) AddListener(listener Listener) {
+	db.lstr = append(db.lstr, listener)
+}
+
+func (db *database) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
+	origsql := sqlstr
+	for _, v := range db.lstr {
+		err := v.PreExec(ctx, nil, &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	res, err := db.db.NamedExecContext(ctx, sqlstr, prep)
+
+	for _, v := range db.lstr {
+		v.PostExec(nil, origsql, sqlstr, prep)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+func (db *database) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
+	origsql := sqlstr
+	for _, v := range db.lstr {
+		err := v.PreQuery(ctx, nil, &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	rows, err := sqlx.NamedQueryContext(ctx, db.db, sqlstr, prep)
+
+	for _, v := range db.lstr {
+		v.PostQuery(nil, origsql, sqlstr, prep)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func (db *database) Ping(ctx context.Context) error {
+	for _, v := range db.lstr {
+		err := v.PrePing(ctx)
+		if err != nil {
+			return err
+		}
+	}
+
+	err := db.db.PingContext(ctx)
+
+	for _, v := range db.lstr {
+		v.PostPing(err)
+	}
+
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel) (Tx, error) {
+	db.lock.Lock()
+	txid := db.txctr
+	db.txctr += 1 // with overflow !
+	db.lock.Unlock()
+
+	for _, v := range db.lstr {
+		err := v.PreTxBegin(ctx, txid)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	xtx, err := db.db.BeginTxx(ctx, &sql.TxOptions{Isolation: iso})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range db.lstr {
+		v.PostTxBegin(txid, err)
+	}
+
+	return NewTransaction(xtx, txid, db.lstr), nil
+}
+
+func (db *database) Exit() error {
+	return db.db.Close()
+}

sq/listener.go

@@ -0,0 +1,19 @@
+package sq
+
+import "context"
+
+type Listener interface {
+	PrePing(ctx context.Context) error
+	PreTxBegin(ctx context.Context, txid uint16) error
+	PreTxCommit(txid uint16) error
+	PreTxRollback(txid uint16) error
+	PreQuery(ctx context.Context, txID *uint16, sql *string, params *PP) error
+	PreExec(ctx context.Context, txID *uint16, sql *string, params *PP) error
+
+	PostPing(result error)
+	PostTxBegin(txid uint16, result error)
+	PostTxCommit(txid uint16, result error)
+	PostTxRollback(txid uint16, result error)
+	PostQuery(txID *uint16, sqlOriginal string, sqlReal string, params PP)
+	PostExec(txID *uint16, sqlOriginal string, sqlReal string, params PP)
+}

sq/params.go

@@ -0,0 +1,13 @@
+package sq
+
+type PP map[string]any
+
+func Join(pps ...PP) PP {
+	r := PP{}
+	for _, add := range pps {
+		for k, v := range add {
+			r[k] = v
+		}
+	}
+	return r
+}

sq/queryable.go

@@ -0,0 +1,12 @@
+package sq
+
+import (
+	"context"
+	"database/sql"
+	"github.com/jmoiron/sqlx"
+)
+
+type Queryable interface {
+	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
+	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
+}

sq/scanner.go

@@ -0,0 +1,140 @@
+package sq
+
+import (
+	"database/sql"
+	"errors"
+	"github.com/jmoiron/sqlx"
+)
+
+type StructScanMode string
+
+const (
+	SModeFast     StructScanMode = "FAST"
+	SModeExtended StructScanMode = "EXTENDED"
+)
+
+type StructScanSafety string
+
+const (
+	Safe   StructScanSafety = "SAFE"
+	Unsafe StructScanSafety = "UNSAFE"
+)
+
+func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) (TData, error) {
+	if rows.Next() {
+		var strscan *StructScanner
+
+		if sec == Safe {
+			strscan = NewStructScanner(rows, false)
+			var data TData
+			err := strscan.Start(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else if sec == Unsafe {
+			strscan = NewStructScanner(rows, true)
+			var data TData
+			err := strscan.Start(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else {
+			return *new(TData), errors.New("unknown value for <sec>")
+		}
+
+		var data TData
+
+		if mode == SModeFast {
+			err := strscan.StructScanBase(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else if mode == SModeExtended {
+			err := strscan.StructScanExt(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else {
+			return *new(TData), errors.New("unknown value for <mode>")
+		}
+
+		if rows.Next() {
+			if close {
+				_ = rows.Close()
+			}
+			return *new(TData), errors.New("sql returned more than one row")
+		}
+
+		if close {
+			err := rows.Close()
+			if err != nil {
+				return *new(TData), err
+			}
+		}
+
+		if err := rows.Err(); err != nil {
+			return *new(TData), err
+		}
+
+		return data, nil
+
+	} else {
+		if close {
+			_ = rows.Close()
+		}
+		return *new(TData), sql.ErrNoRows
+	}
+}
+
+func ScanAll[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) ([]TData, error) {
+	var strscan *StructScanner
+
+	if sec == Safe {
+		strscan = NewStructScanner(rows, false)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return nil, err
+		}
+	} else if sec == Unsafe {
+		strscan = NewStructScanner(rows, true)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		return nil, errors.New("unknown value for <sec>")
+	}
+
+	res := make([]TData, 0)
+	for rows.Next() {
+		if mode == SModeFast {
+			var data TData
+			err := strscan.StructScanBase(&data)
+			if err != nil {
+				return nil, err
+			}
+			res = append(res, data)
+		} else if mode == SModeExtended {
+			var data TData
+			err := strscan.StructScanExt(&data)
+			if err != nil {
+				return nil, err
+			}
+			res = append(res, data)
+		} else {
+			return nil, errors.New("unknown value for <mode>")
+		}
+	}
+	if close {
+		err := strscan.rows.Close()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return res, nil
+}

sq/structscanner.go

@@ -0,0 +1,223 @@
+package sq
+
+import (
+	"errors"
+	"fmt"
+	"github.com/jmoiron/sqlx"
+	"github.com/jmoiron/sqlx/reflectx"
+	"reflect"
+)
+
+// forked from sqlx, but added ability to unmarshal optional-nested structs
+
+type StructScanner struct {
+	rows   *sqlx.Rows
+	Mapper *reflectx.Mapper
+	unsafe bool
+
+	fields  [][]int
+	values  []any
+	columns []string
+}
+
+func NewStructScanner(rows *sqlx.Rows, unsafe bool) *StructScanner {
+	return &StructScanner{
+		rows:   rows,
+		Mapper: reflectx.NewMapper("db"),
+		unsafe: unsafe,
+	}
+}
+
+func (r *StructScanner) Start(dest any) error {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	columns, err := r.rows.Columns()
+	if err != nil {
+		return err
+	}
+
+	r.columns = columns
+	r.fields = r.Mapper.TraversalsByName(v.Type(), columns)
+	// if we are not unsafe and are missing fields, return an error
+	if f, err := missingFields(r.fields); err != nil && !r.unsafe {
+		return fmt.Errorf("missing destination name %s in %T", columns[f], dest)
+	}
+	r.values = make([]interface{}, len(columns))
+
+	return nil
+}
+
+// StructScanExt forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+// does also wok with nullabel structs (from LEFT JOIN's)
+func (r *StructScanner) StructScanExt(dest any) error {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	// ========= STEP 1 ::  =========
+
+	v = v.Elem()
+
+	err := fieldsByTraversalExtended(v, r.fields, r.values)
+	if err != nil {
+		return err
+	}
+	// scan into the struct field pointers and append to our results
+	err = r.rows.Scan(r.values...)
+	if err != nil {
+		return err
+	}
+
+	nullStructs := make(map[string]bool)
+
+	for i, traversal := range r.fields {
+		if len(traversal) == 0 {
+			continue
+		}
+
+		isnsil := reflect.ValueOf(r.values[i]).Elem().IsNil()
+
+		for i := 1; i < len(traversal); i++ {
+
+			canParentNil := reflectx.FieldByIndexes(v, traversal[0:i]).Kind() == reflect.Pointer
+
+			k := fmt.Sprintf("%v", traversal[0:i])
+			if v, ok := nullStructs[k]; ok {
+
+				nullStructs[k] = canParentNil && v && isnsil
+
+			} else {
+				nullStructs[k] = canParentNil && isnsil
+			}
+		}
+
+	}
+
+	forcenulled := make(map[string]bool)
+
+	for i, traversal := range r.fields {
+		if len(traversal) == 0 {
+			continue
+		}
+
+		anyparentnull := false
+		for i := 1; i < len(traversal); i++ {
+			k := fmt.Sprintf("%v", traversal[0:i])
+			if nv, ok := nullStructs[k]; ok && nv {
+
+				if _, ok := forcenulled[k]; !ok {
+					f := reflectx.FieldByIndexes(v, traversal[0:i])
+					f.Set(reflect.Zero(f.Type())) // set to nil
+					forcenulled[k] = true
+				}
+
+				anyparentnull = true
+				break
+
+			}
+		}
+
+		if anyparentnull {
+			continue
+		}
+
+		f := reflectx.FieldByIndexes(v, traversal)
+
+		val1 := reflect.ValueOf(r.values[i])
+		val2 := val1.Elem()
+		val3 := val2.Elem()
+
+		if val2.IsNil() {
+			if f.Kind() != reflect.Pointer {
+				return errors.New(fmt.Sprintf("Cannot set field %v to NULL value from column '%s' (type: %s)", traversal, r.columns[i], f.Type().String()))
+			}
+
+			f.Set(reflect.Zero(f.Type())) // set to nil
+		} else {
+			f.Set(val3)
+		}
+
+	}
+
+	return r.rows.Err()
+}
+
+// StructScanBase forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+// without (relevant) changes
+func (r *StructScanner) StructScanBase(dest any) error {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	v = v.Elem()
+
+	err := fieldsByTraversalBase(v, r.fields, r.values, true)
+	if err != nil {
+		return err
+	}
+	// scan into the struct field pointers and append to our results
+	err = r.rows.Scan(r.values...)
+	if err != nil {
+		return err
+	}
+	return r.rows.Err()
+}
+
+// fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func fieldsByTraversalExtended(v reflect.Value, traversals [][]int, values []interface{}) error {
+	v = reflect.Indirect(v)
+	if v.Kind() != reflect.Struct {
+		return errors.New("argument not a struct")
+	}
+
+	for i, traversal := range traversals {
+		if len(traversal) == 0 {
+			values[i] = new(interface{})
+			continue
+		}
+		f := reflectx.FieldByIndexes(v, traversal)
+
+		values[i] = reflect.New(reflect.PointerTo(f.Type())).Interface()
+	}
+	return nil
+}
+
+// fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func fieldsByTraversalBase(v reflect.Value, traversals [][]int, values []interface{}, ptrs bool) error {
+	v = reflect.Indirect(v)
+	if v.Kind() != reflect.Struct {
+		return errors.New("argument not a struct")
+	}
+
+	for i, traversal := range traversals {
+		if len(traversal) == 0 {
+			values[i] = new(interface{})
+			continue
+		}
+		f := reflectx.FieldByIndexes(v, traversal)
+		if ptrs {
+			values[i] = f.Addr().Interface()
+		} else {
+			values[i] = f.Interface()
+		}
+	}
+	return nil
+}
+
+// missingFields forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func missingFields(transversals [][]int) (field int, err error) {
+	for i, t := range transversals {
+		if len(t) == 0 {
+			return i, errors.New("missing field")
+		}
+	}
+	return 0, nil
+}

sq/transaction.go

@@ -0,0 +1,105 @@
+package sq
+
+import (
+	"context"
+	"database/sql"
+	"github.com/jmoiron/sqlx"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
+
+type Tx interface {
+	Rollback() error
+	Commit() error
+	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
+	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
+}
+
+type transaction struct {
+	tx   *sqlx.Tx
+	id   uint16
+	lstr []Listener
+}
+
+func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
+	return &transaction{
+		tx:   xtx,
+		id:   txid,
+		lstr: lstr,
+	}
+}
+
+func (tx *transaction) Rollback() error {
+	for _, v := range tx.lstr {
+		err := v.PreTxRollback(tx.id)
+		if err != nil {
+			return err
+		}
+	}
+
+	result := tx.tx.Rollback()
+
+	for _, v := range tx.lstr {
+		v.PostTxRollback(tx.id, result)
+	}
+
+	return result
+}
+
+func (tx *transaction) Commit() error {
+	for _, v := range tx.lstr {
+		err := v.PreTxCommit(tx.id)
+		if err != nil {
+			return err
+		}
+	}
+
+	result := tx.tx.Commit()
+
+	for _, v := range tx.lstr {
+		v.PostTxRollback(tx.id, result)
+	}
+
+	return result
+}
+
+func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
+	origsql := sqlstr
+	for _, v := range tx.lstr {
+		err := v.PreExec(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	res, err := tx.tx.NamedExecContext(ctx, sqlstr, prep)
+
+	for _, v := range tx.lstr {
+		v.PostExec(langext.Ptr(tx.id), origsql, sqlstr, prep)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
+	origsql := sqlstr
+	for _, v := range tx.lstr {
+		err := v.PreQuery(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	rows, err := sqlx.NamedQueryContext(ctx, tx.tx, sqlstr, prep)
+
+	for _, v := range tx.lstr {
+		v.PostQuery(langext.Ptr(tx.id), origsql, sqlstr, prep)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}

syncext/atomic.go

@@ -0,0 +1,104 @@
+package syncext
+
+import (
+	"context"
+	"sync/atomic"
+	"time"
+)
+
+type AtomicBool struct {
+	v      int32
+	waiter chan bool // unbuffered
+}
+
+func NewAtomicBool(value bool) *AtomicBool {
+	if value {
+		return &AtomicBool{v: 1, waiter: make(chan bool)}
+	} else {
+		return &AtomicBool{v: 0, waiter: make(chan bool)}
+	}
+}
+
+func (a *AtomicBool) Get() bool {
+	return atomic.LoadInt32(&a.v) == 1
+}
+
+func (a *AtomicBool) Set(value bool) {
+	if value {
+		atomic.StoreInt32(&a.v, 1)
+	} else {
+		atomic.StoreInt32(&a.v, 0)
+	}
+
+	select {
+	case a.waiter <- value:
+		// message sent
+	default:
+		// no receiver on channel
+	}
+}
+
+func (a *AtomicBool) Wait(waitFor bool) {
+	if a.Get() == waitFor {
+		return
+	}
+
+	for {
+		if v, ok := ReadChannelWithTimeout(a.waiter, 128*time.Millisecond); ok {
+			if v == waitFor {
+				return
+			}
+		} else {
+			if a.Get() == waitFor {
+				return
+			}
+		}
+	}
+}
+
+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
+	}
+
+	for {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		timeOut := 128 * 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(a.waiter, timeOut); ok {
+			if v == waitFor {
+				return nil
+			}
+		} else {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
+			if a.Get() == waitFor {
+				return nil
+			}
+		}
+	}
+}

syncext/channel.go

@@ -0,0 +1,45 @@
+package syncext
+
+import (
+	"time"
+)
+
+// https://gobyexample.com/non-blocking-channel-operations
+// https://gobyexample.com/timeouts
+// https://groups.google.com/g/golang-nuts/c/Oth9CmJPoqo
+
+func ReadChannelWithTimeout[T any](c chan T, timeout time.Duration) (T, bool) {
+	select {
+	case msg := <-c:
+		return msg, true
+	case <-time.After(timeout):
+		return *new(T), false
+	}
+}
+
+func WriteChannelWithTimeout[T any](c chan T, msg T, timeout time.Duration) bool {
+	select {
+	case c <- msg:
+		return true
+	case <-time.After(timeout):
+		return false
+	}
+}
+
+func ReadNonBlocking[T any](c chan T) (T, bool) {
+	select {
+	case msg := <-c:
+		return msg, true
+	default:
+		return *new(T), false
+	}
+}
+
+func WriteNonBlocking[T any](c chan T, msg T) bool {
+	select {
+	case c <- msg:
+		return true
+	default:
+		return false
+	}
+}

syncext/channel_test.go

@@ -0,0 +1,121 @@
+package syncext
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTimeoutReadBuffered(t *testing.T) {
+	c := make(chan int, 1)
+
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if ok {
+		t.Error("Read success, but should timeout")
+	}
+}
+
+func TestTimeoutReadBigBuffered(t *testing.T) {
+	c := make(chan int, 128)
+
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if ok {
+		t.Error("Read success, but should timeout")
+	}
+}
+
+func TestTimeoutReadUnbuffered(t *testing.T) {
+	c := make(chan int)
+
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if ok {
+		t.Error("Read success, but should timeout")
+	}
+}
+
+func TestNoTimeoutAfterStartReadBuffered(t *testing.T) {
+	c := make(chan int, 1)
+
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if !ok {
+		t.Error("Read timeout, but should have succeeded")
+	}
+}
+
+func TestNoTimeoutAfterStartReadBigBuffered(t *testing.T) {
+	c := make(chan int, 128)
+
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if !ok {
+		t.Error("Read timeout, but should have succeeded")
+	}
+}
+
+func TestNoTimeoutAfterStartReadUnbuffered(t *testing.T) {
+	c := make(chan int)
+
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		c <- 112
+	}()
+
+	_, ok := ReadChannelWithTimeout(c, 100*time.Millisecond)
+
+	if !ok {
+		t.Error("Read timeout, but should have succeeded")
+	}
+
+}
+
+func TestNoTimeoutBeforeStartReadBuffered(t *testing.T) {
+	c := make(chan int, 1)
+
+	c <- 112
+
+	_, ok := ReadChannelWithTimeout(c, 10*time.Millisecond)
+
+	if !ok {
+		t.Error("Read timeout, but should have succeeded")
+	}
+}
+
+func TestNoTimeoutBeforeStartReadBigBuffered(t *testing.T) {
+	c := make(chan int, 128)
+
+	c <- 112
+
+	_, ok := ReadChannelWithTimeout(c, 10*time.Millisecond)
+
+	if !ok {
+		t.Error("Read timeout, but should have succeeded")
+	}
+}

termext/osutil_freebsd.go

@@ -0,0 +1,5 @@
+package termext
+
+func enableColor() bool {
+	return true
+}

termext/osutil_netbsd.go

@@ -0,0 +1,5 @@
+package termext
+
+func enableColor() bool {
+	return true
+}

termext/osutil_openbsd.go

@@ -0,0 +1,5 @@
+package termext
+
+func enableColor() bool {
+	return true
+}

timeext/duration.go

@@ -2,59 +2,36 @@ package timeext
 
 import (
 	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
-func FromSeconds(v int) time.Duration {
-	return time.Duration(int64(v) * int64(time.Second))
+func FromNanoseconds[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Nanosecond)))
 }
 
-func FromSecondsInt32(v int32) time.Duration {
-	return time.Duration(int64(v) * int64(time.Second))
+func FromMicroseconds[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Microsecond)))
 }
 
-func FromSecondsInt64(v int64) time.Duration {
-	return time.Duration(v * int64(time.Second))
+func FromMilliseconds[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Millisecond)))
 }
 
-func FromSecondsFloat32(v float32) time.Duration {
-	return time.Duration(int64(v * float32(time.Second)))
+func FromSeconds[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Second)))
 }
 
-func FromSecondsFloat64(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Second)))
+func FromMinutes[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Minute)))
 }
 
-func FromSecondsFloat(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Second)))
+func FromHours[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(time.Hour)))
 }
 
-func FromMinutes(v int) time.Duration {
-	return time.Duration(int64(v) * int64(time.Minute))
-}
-
-func FromMinutesFloat(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Minute)))
-}
-
-func FromMinutesFloat64(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Minute)))
-}
-
-func FromHoursFloat64(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Hour)))
-}
-
-func FromDays(v int) time.Duration {
-	return time.Duration(int64(v) * int64(24) * int64(time.Hour))
-}
-
-func FromMilliseconds(v int) time.Duration {
-	return time.Duration(int64(v) * int64(time.Millisecond))
-}
-
-func FromMillisecondsFloat(v float64) time.Duration {
-	return time.Duration(int64(v * float64(time.Millisecond)))
+func FromDays[T langext.NumberConstraint](v T) time.Duration {
+	return time.Duration(int64(float64(v) * float64(24) * float64(time.Hour)))
 }
 
 func FormatNaturalDurationEnglish(iv time.Duration) string {

timeext/parser.go

@@ -0,0 +1,152 @@
+package timeext
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var durationShortStringMap = map[string]time.Duration{
+	"ns":          time.Nanosecond,
+	"nanosecond":  time.Nanosecond,
+	"nanoseconds": time.Nanosecond,
+
+	"us":           time.Microsecond,
+	"microsecond":  time.Microsecond,
+	"microseconds": time.Microsecond,
+
+	"ms":           time.Millisecond,
+	"millisecond":  time.Millisecond,
+	"milliseconds": time.Millisecond,
+
+	"s":       time.Second,
+	"sec":     time.Second,
+	"second":  time.Second,
+	"seconds": time.Second,
+
+	"m":       time.Minute,
+	"min":     time.Minute,
+	"minute":  time.Minute,
+	"minutes": time.Minute,
+
+	"h":     time.Hour,
+	"hour":  time.Hour,
+	"hours": time.Hour,
+
+	"d":    24 * time.Hour,
+	"day":  24 * time.Hour,
+	"days": 24 * time.Hour,
+
+	"w":     7 * 24 * time.Hour,
+	"wk":    7 * 24 * time.Hour,
+	"week":  7 * 24 * time.Hour,
+	"weeks": 7 * 24 * time.Hour,
+}
+
+// ParseDurationShortString parses a duration in string format to a time.Duration
+// Examples for allowed formats:
+//   - '10m'
+//   - '10min'
+//   - '1minute'
+//   - '10minutes'
+//   - '10.5minutes'
+//   - '50s'
+//   - '50sec'
+//   - '1second'
+//   - '50seconds'
+//   - '100ms'
+//   - '100millisseconds'
+//   - '1h'
+//   - '1hour'
+//   - '2hours'
+//   - '1d'
+//   - '1day'
+//   - '10days'
+//   - '1d10m'
+//   - '1d10m200sec'
+//   - '1d:10m'
+//   - '1d 10m'
+//   - '1d,10m'
+func ParseDurationShortString(s string) (time.Duration, error) {
+	s = strings.ToLower(s)
+
+	segments := make([]string, 0)
+	collector := ""
+
+	prevWasNum := true
+	for _, chr := range s {
+		if chr >= '0' && chr <= '9' || chr == '.' {
+			if prevWasNum {
+				collector += string(chr)
+			} else {
+				segments = append(segments, collector)
+				prevWasNum = true
+				collector = string(chr)
+			}
+		} else if chr == ' ' || chr == ':' || chr == ',' {
+			continue
+		} else if chr >= 'a' && chr <= 'z' {
+			prevWasNum = false
+			collector += string(chr)
+		} else {
+			return 0, errors.New("unexpected character: " + string(chr))
+		}
+	}
+	if !prevWasNum {
+		segments = append(segments, collector)
+	}
+
+	result := time.Duration(0)
+	for _, seg := range segments {
+		segDur, err := parseDurationShortStringSegment(seg)
+		if err != nil {
+			return 0, err
+		}
+		result += segDur
+	}
+	return result, nil
+}
+
+func parseDurationShortStringSegment(segment string) (time.Duration, error) {
+	num := ""
+	unit := ""
+
+	part0 := true
+	for _, chr := range segment {
+		if part0 {
+
+			if chr >= 'a' && chr <= 'z' {
+				part0 = false
+				unit += string(chr)
+			} else if chr >= '0' && chr <= '9' || chr == '.' {
+				num += string(chr)
+			} else {
+				return 0, errors.New(fmt.Sprintf("Unexpected character '%s' in segment [%s]", string(chr), segment))
+			}
+
+		} else {
+
+			if chr >= 'a' && chr <= 'z' {
+				unit += string(chr)
+			} else if chr >= '0' && chr <= '9' || chr == '.' {
+				return 0, errors.New(fmt.Sprintf("Unexpected number '%s' in segment [%s]", string(chr), segment))
+			} else {
+				return 0, errors.New(fmt.Sprintf("Unexpected character '%s' in segment [%s]", string(chr), segment))
+			}
+
+		}
+	}
+
+	fpnum, err := strconv.ParseFloat(num, 64)
+	if err != nil {
+		return 0, errors.New(fmt.Sprintf("Failed to parse floating-point number '%s' in segment [%s]", num, segment))
+	}
+
+	if mult, ok := durationShortStringMap[unit]; ok {
+		return time.Duration(int64(fpnum * float64(mult))), nil
+	} else {
+		return 0, errors.New(fmt.Sprintf("Unknown unit '%s' in segment [%s]", unit, segment))
+	}
+}

timeext/parser_test.go

@@ -0,0 +1,70 @@
+package timeext
+
+import (
+	"testing"
+	"time"
+)
+
+func TestParseDurationShortString(t *testing.T) {
+
+	assertPDSSEqual(t, FromSeconds(1), "1s")
+	assertPDSSEqual(t, FromSeconds(1), "1sec")
+	assertPDSSEqual(t, FromSeconds(1), "1second")
+	assertPDSSEqual(t, FromSeconds(1), "1seconds")
+	assertPDSSEqual(t, FromSeconds(100), "100second")
+	assertPDSSEqual(t, FromSeconds(100), "100seconds")
+	assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77second")
+	assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77seconds")
+	assertPDSSEqual(t, FromSeconds(50), "50s")
+	assertPDSSEqual(t, FromSeconds(50), "50sec")
+	assertPDSSEqual(t, FromSeconds(1), "1second")
+	assertPDSSEqual(t, FromSeconds(50), "50seconds")
+
+	assertPDSSEqual(t, FromMinutes(10), "10m")
+	assertPDSSEqual(t, FromMinutes(10), "10min")
+	assertPDSSEqual(t, FromMinutes(1), "1minute")
+	assertPDSSEqual(t, FromMinutes(10), "10minutes")
+	assertPDSSEqual(t, FromMinutes(10.5), "10.5minutes")
+
+	assertPDSSEqual(t, FromMilliseconds(100), "100ms")
+	assertPDSSEqual(t, FromMilliseconds(100), "100milliseconds")
+	assertPDSSEqual(t, FromMilliseconds(100), "100millisecond")
+
+	assertPDSSEqual(t, FromNanoseconds(99235), "99235ns")
+	assertPDSSEqual(t, FromNanoseconds(99235), "99235nanoseconds")
+	assertPDSSEqual(t, FromNanoseconds(99235), "99235nanosecond")
+
+	assertPDSSEqual(t, FromMicroseconds(99235), "99235us")
+	assertPDSSEqual(t, FromMicroseconds(99235), "99235microseconds")
+	assertPDSSEqual(t, FromMicroseconds(99235), "99235microsecond")
+
+	assertPDSSEqual(t, FromHours(1), "1h")
+	assertPDSSEqual(t, FromHours(1), "1hour")
+	assertPDSSEqual(t, FromHours(2), "2hours")
+
+	assertPDSSEqual(t, FromDays(1), "1d")
+	assertPDSSEqual(t, FromDays(1), "1day")
+	assertPDSSEqual(t, FromDays(10), "10days")
+	assertPDSSEqual(t, FromDays(1), "1days")
+	assertPDSSEqual(t, FromDays(10), "10day")
+
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d10m")
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10)+FromSeconds(200), "1d10m200sec")
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d:10m")
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d 10m")
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d,10m")
+	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d, 10m")
+	assertPDSSEqual(t, FromDays(1)+FromSeconds(1000), "1d   1000seconds")
+
+	assertPDSSEqual(t, FromDays(1), "86400s")
+}
+
+func assertPDSSEqual(t *testing.T, expected time.Duration, fmt string) {
+	actual, err := ParseDurationShortString(fmt)
+	if err != nil {
+		t.Errorf("ParseDurationShortString('%s') failed with %v", fmt, err)
+	}
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual.String(), expected.String())
+	}
+}