exerr [WIP]

_data/version.sh

@@ -7,20 +7,6 @@ set -o pipefail  # Return value of a pipeline is the value of the last (rightmos
 IFS=$'\n\t'      # Set $IFS to only newline and tab.
 
 
-function black() { echo -e "\x1B[30m $1 \x1B[0m"; }
-function red()   { echo -e "\x1B[31m $1 \x1B[0m"; }
-function green() { echo -e "\x1B[32m $1 \x1B[0m"; }
-function yellow(){ echo -e "\x1B[33m $1 \x1B[0m"; }
-function blue()  { echo -e "\x1B[34m $1 \x1B[0m"; }
-function purple(){ echo -e "\x1B[35m $1 \x1B[0m"; }
-function cyan()  { echo -e "\x1B[36m $1 \x1B[0m"; }
-function white() { echo -e "\x1B[37m $1 \x1B[0m"; }
-
-if [ "$( git rev-parse --abbrev-ref HEAD )" != "master" ]; then
-  >&2 red "[ERROR] Can only create versions of <master>"
-  exit 1
-fi
-
 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}')
@@ -32,13 +18,7 @@ echo ""
 
 git add --verbose .
 
-msg="v${next_ver}"
-
-if [ $# -gt 0 ]; then
-  msg="$1"
-fi
-
-git commit -a -m "${msg}"
+git commit -a -m "v${next_ver}"
 
 git tag "v${next_ver}"
 

cmdext/builder.go

@@ -2,7 +2,6 @@ package cmdext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -12,8 +11,6 @@ type CommandRunner struct {
 	timeout  *time.Duration
 	env      []string
 	listener []CommandListener
-	enforceExitCodes *[]int
-	enforceNoTimeout bool
 }
 
 func Runner(program string) *CommandRunner {
@@ -23,8 +20,6 @@ func Runner(program string) *CommandRunner {
 		timeout:  nil,
 		env:      make([]string, 0),
 		listener: make([]CommandListener, 0),
-		enforceExitCodes: nil,
-		enforceNoTimeout: false,
 	}
 }
 
@@ -58,21 +53,6 @@ func (r *CommandRunner) Envs(env []string) *CommandRunner {
 	return r
 }
 
-func (r *CommandRunner) EnsureExitcode(arg ...int) *CommandRunner {
-	r.enforceExitCodes = langext.Ptr(langext.ForceArray(arg))
-	return r
-}
-
-func (r *CommandRunner) FailOnExitCode() *CommandRunner {
-	r.enforceExitCodes = langext.Ptr([]int{0})
-	return r
-}
-
-func (r *CommandRunner) FailOnTimeout() *CommandRunner {
-	r.enforceNoTimeout = true
-	return r
-}
-
 func (r *CommandRunner) Listen(lstr CommandListener) *CommandRunner {
 	r.listener = append(r.listener, lstr)
 	return r

cmdext/cmdrunner.go

@@ -1,17 +1,12 @@
 package cmdext
 
 import (
-	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
 	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
 	"os/exec"
 	"time"
 )
 
-var ErrExitCode = errors.New("process exited with an unexpected exitcode")
-var ErrTimeout = errors.New("process did not exit after the specified timeout")
-
 type CommandResult struct {
 	StdOut          string
 	StdErr          string
@@ -36,7 +31,6 @@ func run(opt CommandRunner) (CommandResult, error) {
 	}
 
 	preader := pipeReader{
-		lineBufferSize: langext.Ptr(128 * 1024 * 1024), // 128MB max size of a single line, is hopefully enough....
 		stdout: stdoutPipe,
 		stderr: stderrPipe,
 	}
@@ -61,17 +55,14 @@ func run(opt CommandRunner) (CommandResult, error) {
 		stdout, stderr, stdcombined, err := preader.Read(opt.listener)
 		if err != nil {
 			outputChan <- resultObj{stdout, stderr, stdcombined, err}
-			_ = cmd.Process.Kill()
-			return
 		}
 
 		err = cmd.Wait()
 		if err != nil {
 			outputChan <- resultObj{stdout, stderr, stdcombined, err}
-		} else {
-			outputChan <- resultObj{stdout, stderr, stdcombined, nil}
 		}
 
+		outputChan <- resultObj{stdout, stderr, stdcombined, nil}
 	}()
 
 	var timeoutChan <-chan time.Time = make(chan time.Time, 1)
@@ -90,29 +81,21 @@ func run(opt CommandRunner) (CommandResult, error) {
 		if fallback, ok := syncext.ReadChannelWithTimeout(outputChan, mathext.Min(32*time.Millisecond, *opt.timeout)); ok {
 			// most of the time the cmd.Process.Kill() should also ahve finished the pipereader
 			// and we can at least return the already collected stdout, stderr, etc
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          fallback.stdout,
 				StdErr:          fallback.stderr,
 				StdCombined:     fallback.stdcombined,
 				ExitCode:        -1,
 				CommandTimedOut: true,
-			}
-			if opt.enforceNoTimeout {
-				return res, ErrTimeout
-			}
-			return res, nil
+			}, nil
 		} else {
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          "",
 				StdErr:          "",
 				StdCombined:     "",
 				ExitCode:        -1,
 				CommandTimedOut: true,
-			}
-			if opt.enforceNoTimeout {
-				return res, ErrTimeout
-			}
-			return res, nil
+			}, nil
 		}
 
 	case outobj := <-outputChan:
@@ -121,34 +104,26 @@ func run(opt CommandRunner) (CommandResult, error) {
 			for _, lstr := range opt.listener {
 				lstr.Finished(excode)
 			}
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          outobj.stdout,
 				StdErr:          outobj.stderr,
 				StdCombined:     outobj.stdcombined,
 				ExitCode:        excode,
 				CommandTimedOut: false,
-			}
-			if opt.enforceExitCodes != nil && !langext.InArray(excode, *opt.enforceExitCodes) {
-				return res, ErrExitCode
-			}
-			return res, nil
+			}, nil
 		} else if err != nil {
 			return CommandResult{}, err
 		} else {
 			for _, lstr := range opt.listener {
 				lstr.Finished(0)
 			}
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          outobj.stdout,
 				StdErr:          outobj.stderr,
 				StdCombined:     outobj.stdcombined,
 				ExitCode:        0,
 				CommandTimedOut: false,
-			}
-			if opt.enforceExitCodes != nil && !langext.InArray(0, *opt.enforceExitCodes) {
-				return res, ErrExitCode
-			}
-			return res, nil
+			}, nil
 		}
 	}
 }

cmdext/cmdrunner_test.go

@@ -12,12 +12,6 @@ func TestStdout(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -36,12 +30,6 @@ func TestStderr(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "error" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -62,12 +50,6 @@ func TestStdcombined(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "1\n3\n" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -134,12 +116,6 @@ func TestReadUnflushedStdout(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -158,12 +134,6 @@ func TestReadUnflushedStderr(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "message101" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -230,7 +200,7 @@ func TestPartialReadUnflushedStderr(t *testing.T) {
 
 func TestListener(t *testing.T) {
 
-	res1, err := Runner("python").
+	_, err := Runner("python").
 		Arg("-c").
 		Arg("import sys;" +
 			"import time;" +
@@ -253,71 +223,4 @@ func TestListener(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
-}
-
-func TestLongStdout(t *testing.T) {
-
-	res1, err := Runner("python").
-		Arg("-c").
-		Arg("import sys; import time; print(\"X\" * 125001 + \"\\n\"); print(\"Y\" * 125001 + \"\\n\"); print(\"Z\" * 125001 + \"\\n\");").
-		Timeout(5000 * time.Millisecond).
-		Run()
-	if err != nil {
-		t.Errorf("%v", err)
-	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
-	if res1.StdErr != "" {
-		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
-	}
-	if len(res1.StdOut) != 375009 {
-		t.Errorf("len(res1.StdOut) == '%v'", len(res1.StdOut))
-	}
-
-}
-
-func TestFailOnTimeout(t *testing.T) {
-
-	_, err := Runner("sleep").Arg("2").Timeout(200 * time.Millisecond).FailOnTimeout().Run()
-	if err != ErrTimeout {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestFailOnExitcode(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200 * time.Millisecond).FailOnExitCode().Run()
-	if err != ErrExitCode {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestEnsureExitcode1(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200 * time.Millisecond).EnsureExitcode(1).Run()
-	if err != nil {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestEnsureExitcode2(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200*time.Millisecond).EnsureExitcode(0, 2, 3).Run()
-	if err != ErrExitCode {
-		t.Errorf("wrong err := %v", err)
-	}
-
 }

cmdext/pipereader.go

@@ -8,7 +8,6 @@ import (
 )
 
 type pipeReader struct {
-	lineBufferSize *int
 	stdout io.ReadCloser
 	stderr io.ReadCloser
 }
@@ -34,6 +33,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 		buf := make([]byte, 128)
 		for true {
 			n, out := pr.stdout.Read(buf)
+
 			if n > 0 {
 				txt := string(buf[:n])
 				stdout += txt
@@ -91,9 +91,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	wg.Add(1)
 	go func() {
 		scanner := bufio.NewScanner(stdoutBufferReader)
-		if pr.lineBufferSize != nil {
-			scanner.Buffer([]byte{}, *pr.lineBufferSize)
-		}
 		for scanner.Scan() {
 			txt := scanner.Text()
 			for _, lstr := range listener {
@@ -101,9 +98,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			}
 			combch <- combevt{txt, false}
 		}
-		if err := scanner.Err(); err != nil {
-			errch <- err
-		}
 		combch <- combevt{"", true}
 		wg.Done()
 	}()
@@ -113,9 +107,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	wg.Add(1)
 	go func() {
 		scanner := bufio.NewScanner(stderrBufferReader)
-		if pr.lineBufferSize != nil {
-			scanner.Buffer([]byte{}, *pr.lineBufferSize)
-		}
 		for scanner.Scan() {
 			txt := scanner.Text()
 			for _, lstr := range listener {
@@ -123,9 +114,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			}
 			combch <- combevt{txt, false}
 		}
-		if err := scanner.Err(); err != nil {
-			errch <- err
-		}
 		combch <- combevt{"", true}
 		wg.Done()
 	}()

confext/confParser.go

@@ -22,10 +22,10 @@ import (
 //
 // sub-structs are recursively parsed (if they have an env tag) and the env-variable keys are delimited by the delim parameter
 // sub-structs with `env:""` are also parsed, but the delimited is skipped (they are handled as if they were one level higher)
-func ApplyEnvOverrides[T any](prefix string, c *T, delim string) error {
+func ApplyEnvOverrides[T any](c *T, delim string) error {
 	rval := reflect.ValueOf(c).Elem()
 
-	return processEnvOverrides(rval, delim, prefix)
+	return processEnvOverrides(rval, delim, "")
 }
 
 func processEnvOverrides(rval reflect.Value, delim string, prefix string) error {
@@ -70,114 +70,103 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			continue
 		}
 
-		if rvfield.Type().Kind() == reflect.Pointer {
+		if rvfield.Type() == reflect.TypeOf("") {
 
-			newval, err := parseEnvToValue(envval, fullEnvKey, rvfield.Type().Elem())
-			if err != nil {
-				return err
-			}
-
-			// converts reflect.Value to pointer
-			ptrval := reflect.New(rvfield.Type().Elem())
-			ptrval.Elem().Set(newval)
-
-			rvfield.Set(ptrval)
+			rvfield.Set(reflect.ValueOf(envval))
 
 			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int64(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int32(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int8(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(dur))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(tim))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, 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(), fullEnvKey, envval))
+			}
+
+			envcvl := reflect.ValueOf(envint).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", fullEnvKey, 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", fullEnvKey, envcvl.Interface())
+
 		} else {
-
-			newval, err := parseEnvToValue(envval, fullEnvKey, rvfield.Type())
-			if err != nil {
-				return err
+			return errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvfield.Kind().String(), rvfield.Type().String()))
 		}
-
-			rvfield.Set(newval)
-			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
-
-		}
-
 	}
 
 	return nil
 }
-
-func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (reflect.Value, error) {
-	if rvtype == reflect.TypeOf("") {
-
-		return reflect.ValueOf(envval), nil
-
-	} else if rvtype == reflect.TypeOf(int(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int64(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 64)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int64 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int64(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int32(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 32)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int32(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int8(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 8)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int8(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(time.Duration(0)) {
-
-		dur, err := timeext.ParseDurationShortString(envval)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to duration (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(dur), nil
-
-	} else if rvtype == reflect.TypeOf(time.UnixMilli(0)) {
-
-		tim, err := time.Parse(time.RFC3339Nano, envval)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to time.time (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(tim), nil
-
-	} else if rvtype.ConvertibleTo(reflect.TypeOf(int(0))) {
-
-		envint, err := strconv.ParseInt(envval, 10, 8)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,int> (value := '%s')", rvtype.Name(), fullEnvKey, envval))
-		}
-
-		envcvl := reflect.ValueOf(envint).Convert(rvtype)
-
-		return envcvl, nil
-
-	} else if rvtype.ConvertibleTo(reflect.TypeOf("")) {
-
-		envcvl := reflect.ValueOf(envval).Convert(rvtype)
-		return envcvl, nil
-
-	} else {
-		return reflect.Value{}, errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvtype.Kind().String(), rvtype.String()))
-	}
-}

confext/confParser_test.go

@@ -213,65 +213,8 @@ func TestApplyEnvOverridesRecursive(t *testing.T) {
 	assertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC())
 }
 
-func TestApplyEnvOverridesPointer(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{}
-
-	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()
-	}
-
-	assertPtrEqual(t, data.V1, 846)
-	assertPtrEqual(t, data.V2, "hello_world")
-	assertPtrEqual(t, data.V3, 6)
-	assertPtrEqual(t, data.V4, 333)
-	assertPtrEqual(t, data.V5, -937)
-	assertPtrEqual(t, data.V6, 70)
-	assertPtrEqual(t, data.V7, "AAAAAA")
-	assertPtrEqual(t, data.V8, time.Second*64)
-	assertPtrEqual(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)
 	}
 }
-
-func assertPtrEqual[T comparable](t *testing.T, actual *T, expected T) {
-	if actual == nil {
-		t.Errorf("values differ: Actual: NIL, Expected: '%v'", expected)
-	}
-	if *actual != expected {
-		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
-	}
-}

dataext/lruMap_test.go

@@ -12,7 +12,7 @@ func init() {
 }
 
 func TestResultCache1(t *testing.T) {
-	cache := NewLRUMap[string, string](8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key := randomKey()
@@ -50,7 +50,7 @@ func TestResultCache1(t *testing.T) {
 }
 
 func TestResultCache2(t *testing.T) {
-	cache := NewLRUMap[string, string](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[string, string](8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -173,7 +173,7 @@ func TestResultCache3(t *testing.T) {
 }
 
 // does a basic consistency check over the internal cache representation
-func verifyLRUList[TKey comparable, TData any](cache *LRUMap[TKey, TData], t *testing.T) {
+func verifyLRUList[TData any](cache *LRUMap[TData], t *testing.T) {
 	size := 0
 
 	tailFound := false

exerr/builder.go

@@ -0,0 +1,416 @@
+package exerr
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"net/http"
+	"os"
+	"runtime/debug"
+	"strings"
+	"time"
+)
+
+//
+// ==== USAGE =====
+//
+// If some method returns an error _always wrap it into an bmerror:
+//     value, err := do_something(..)
+//     if err != nil {
+//         return nil, bmerror.Wrap(err, "do something failed").Build()
+//     }
+//
+// If possible add metadata to the error (eg the id that was not found, ...), the methods are the same as in zerolog
+//     return nil, bmerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
+//
+// You can change the errortype with `.User()` and `.System()` (User-errors are 400 and System-errors 500)
+// You can also manually set the statuscode with `.WithStatuscode(http.NotFound)`
+// You can set the type with `WithType(..)`
+//
+// New Errors (that don't wrap an existing err object) are created with New
+//     return nil, bmerror.New(bmerror.ErrInternal, "womethign wen horrible wrong").Build()
+// You can eitehr use an existing ErrorType, the "catch-all" ErrInternal, or add you own ErrType in consts.go
+//
+// All errors should be handled one of the following four ways:
+//   - return the error to the caller and let him handle it:
+//     (also auto-prints the error to the log)
+//     => Wrap/New + Build
+//   - Print the error
+//     (also auto-sends it to the error-service)
+//     This is useful for errors that happen asynchron or are non-fatal for the current request
+//     => Wrap/New + Print
+//   - Return the error to the Rest-API caller
+//     (also auto-prints the error to the log)
+//     (also auto-sends it to the error-service)
+//     => Wrap/New + Output
+//   - Print and stop the service
+//     (also auto-sends it to the error-service)
+//     => Wrap/New + Fatal
+//
+
+var stackSkipLogger zerolog.Logger
+
+func init() {
+	cw := zerolog.ConsoleWriter{
+		Out:        os.Stdout,
+		TimeFormat: "2006-01-02 15:04:05 Z07:00",
+	}
+
+	multi := zerolog.MultiLevelWriter(cw)
+	stackSkipLogger = zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
+}
+
+type Builder struct {
+	bmerror *bringmanError
+
+	containsGinData bool
+}
+
+func Get(err error) *Builder {
+	return &Builder{bmerror: fromError(err)}
+}
+
+func New(t ErrorType, msg string) *Builder {
+	return &Builder{bmerror: newBringmanErr(CatSystem, t, msg)}
+}
+
+func Wrap(err error, msg string) *Builder {
+	return &Builder{bmerror: fromError(err).wrap(msg, CatWrap, 1)}
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) WithType(t ErrorType) *Builder {
+	b.bmerror.Type = t
+	return b
+}
+
+func (b *Builder) WithStatuscode(status int) *Builder {
+	b.bmerror.StatusCode = status
+	return b
+}
+
+func (b *Builder) WithMessage(msg string) *Builder {
+	b.bmerror.Message = msg
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+// Err changes the Severity to ERROR (default)
+// The error will be:
+//
+//   - On Build():
+//
+//   - Short-Logged as Err
+//
+//   - On Print():
+//
+//   - Logged as Err
+//
+//   - Send to the error-service
+//
+//   - On Output():
+//
+//   - Logged as Err
+//
+//   - Send to the error-service
+func (b *Builder) Err() *Builder {
+	b.bmerror.Severity = SevErr
+	return b
+}
+
+// Warn changes the Severity to WARN
+// The error will be:
+//
+//   - On Build():
+//
+//   - -(nothing)-
+//
+//   - On Print():
+//
+//   - Short-Logged as Warn
+//
+//   - On Output():
+//
+//   - Logged as Warn
+func (b *Builder) Warn() *Builder {
+	b.bmerror.Severity = SevWarn
+	return b
+}
+
+// Info changes the Severity to INFO
+// The error will be:
+//
+//   - On Build():
+//
+//   - -(nothing)-
+//
+//   - On Print():
+//
+//   - -(nothing)-
+//
+//   - On Output():
+//
+//   - -(nothing)-
+func (b *Builder) Info() *Builder {
+	b.bmerror.Severity = SevInfo
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+// User sets the Category to CatUser
+//
+// Errors with category
+func (b *Builder) User() *Builder {
+	b.bmerror.Category = CatUser
+	return b
+}
+
+func (b *Builder) System() *Builder {
+	b.bmerror.Category = CatSystem
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) Id(key string, val fmt.Stringer) *Builder {
+	return b.addMeta(key, MDTID, newIDWrap(val))
+}
+
+func (b *Builder) StrPtr(key string, val *string) *Builder {
+	return b.addMeta(key, MDTStringPtr, val)
+}
+
+func (b *Builder) Str(key string, val string) *Builder {
+	return b.addMeta(key, MDTString, val)
+}
+
+func (b *Builder) Int(key string, val int) *Builder {
+	return b.addMeta(key, MDTInt, val)
+}
+
+func (b *Builder) Int8(key string, val int8) *Builder {
+	return b.addMeta(key, MDTInt8, val)
+}
+
+func (b *Builder) Int16(key string, val int16) *Builder {
+	return b.addMeta(key, MDTInt16, val)
+}
+
+func (b *Builder) Int32(key string, val int32) *Builder {
+	return b.addMeta(key, MDTInt32, val)
+}
+
+func (b *Builder) Int64(key string, val int64) *Builder {
+	return b.addMeta(key, MDTInt64, val)
+}
+
+func (b *Builder) Float32(key string, val float32) *Builder {
+	return b.addMeta(key, MDTFloat32, val)
+}
+
+func (b *Builder) Float64(key string, val float64) *Builder {
+	return b.addMeta(key, MDTFloat64, val)
+}
+
+func (b *Builder) Bool(key string, val bool) *Builder {
+	return b.addMeta(key, MDTBool, val)
+}
+
+func (b *Builder) Bytes(key string, val []byte) *Builder {
+	return b.addMeta(key, MDTBytes, val)
+}
+
+func (b *Builder) ObjectID(key string, val primitive.ObjectID) *Builder {
+	return b.addMeta(key, MDTObjectID, val)
+}
+
+func (b *Builder) Time(key string, val time.Time) *Builder {
+	return b.addMeta(key, MDTTime, val)
+}
+
+func (b *Builder) Dur(key string, val time.Duration) *Builder {
+	return b.addMeta(key, MDTDuration, val)
+}
+
+func (b *Builder) Strs(key string, val []string) *Builder {
+	return b.addMeta(key, MDTStringArray, val)
+}
+
+func (b *Builder) Ints(key string, val []int) *Builder {
+	return b.addMeta(key, MDTIntArray, val)
+}
+
+func (b *Builder) Ints32(key string, val []int32) *Builder {
+	return b.addMeta(key, MDTInt32Array, val)
+}
+
+func (b *Builder) Type(key string, cls interface{}) *Builder {
+	return b.addMeta(key, MDTString, fmt.Sprintf("%T", cls))
+}
+
+func (b *Builder) Interface(key string, val interface{}) *Builder {
+	return b.addMeta(key, MDTAny, newAnyWrap(val))
+}
+
+func (b *Builder) Any(key string, val any) *Builder {
+	return b.addMeta(key, MDTAny, newAnyWrap(val))
+}
+
+func (b *Builder) Stack() *Builder {
+	return b.addMeta("@Stack", MDTString, string(debug.Stack()))
+}
+
+func (b *Builder) Errs(key string, val []error) *Builder {
+	for i, valerr := range val {
+		b.addMeta(fmt.Sprintf("%v[%v]", key, i), MDTString, Get(valerr).toBMError().FormatLog(LogPrintFull))
+	}
+	return b
+}
+
+func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request) *Builder {
+	if v := ctx.Value("start_timestamp"); v != nil {
+		if t, ok := v.(time.Time); ok {
+			b.Time("ctx.startTimestamp", t)
+			b.Time("ctx.endTimestamp", time.Now())
+		}
+	}
+	b.Str("gin.method", req.Method)
+	b.Str("gin.path", g.FullPath())
+	b.Str("gin.header", formatHeader(g.Request.Header))
+	if req.URL != nil {
+		b.Str("gin.url", req.URL.String())
+	}
+	if ctxVal := g.GetString("apiversion"); ctxVal != "" {
+		b.Str("gin.context.apiversion", ctxVal)
+	}
+	if ctxVal := g.GetString("uid"); ctxVal != "" {
+		b.Str("gin.context.uid", ctxVal)
+	}
+	if ctxVal := g.GetString("fcmId"); ctxVal != "" {
+		b.Str("gin.context.fcmid", ctxVal)
+	}
+	if ctxVal := g.GetString("reqid"); ctxVal != "" {
+		b.Str("gin.context.reqid", ctxVal)
+	}
+	if req.Method != "GET" && req.Body != nil && req.Header.Get("Content-Type") == "application/json" {
+		if brc, ok := req.Body.(langext.BufferedReadCloser); ok {
+			if bin, err := brc.BufferedAll(); err == nil {
+				if len(bin) < 16*1024 {
+					var prettyJSON bytes.Buffer
+					err = json.Indent(&prettyJSON, bin, "", "  ")
+					if err == nil {
+						b.Str("gin.body", string(prettyJSON.Bytes()))
+					} else {
+						b.Bytes("gin.body", bin)
+					}
+				} else {
+					b.Str("gin.body", fmt.Sprintf("[[%v bytes]]", len(bin)))
+				}
+			}
+		}
+	}
+
+	b.containsGinData = true
+	return b
+}
+
+func formatHeader(header map[string][]string) string {
+	ml := 1
+	for k, _ := range header {
+		if len(k) > ml {
+			ml = len(k)
+		}
+	}
+	r := ""
+	for k, v := range header {
+		if r != "" {
+			r += "\n"
+		}
+		for _, hval := range v {
+			value := hval
+			value = strings.ReplaceAll(value, "\n", "\\n")
+			value = strings.ReplaceAll(value, "\r", "\\r")
+			value = strings.ReplaceAll(value, "\t", "\\t")
+			r += langext.StrPadRight(k, " ", ml) + " := " + value
+		}
+	}
+	return r
+}
+
+// ----------------------------------------------------------------------------
+
+// Build creates a new error, ready to pass up the stack
+// If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
+func (b *Builder) Build() error {
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.ShortLog(stackSkipLogger.Error())
+	}
+
+	b.CallListener(MethodBuild)
+
+	return b.bmerror.ToGrpcError()
+}
+
+// Output prints the error onto the gin stdout.
+// The error also gets printed to stdout/stderr
+// If the error is SevErr|SevFatal we also send it to the error-service
+func (b *Builder) Output(ctx context.Context, g *gin.Context) {
+	if !b.containsGinData && g.Request != nil {
+		// Auto-Add gin metadata if the caller hasn't already done it
+		b.GinReq(ctx, g, g.Request)
+	}
+
+	b.bmerror.Output(ctx, g)
+
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.Log(stackSkipLogger.Error())
+	} else if b.bmerror.Severity == SevWarn {
+		b.bmerror.Log(stackSkipLogger.Warn())
+	}
+
+	b.CallListener(MethodOutput)
+}
+
+// Print prints the error
+// If the error is SevErr we also send it to the error-service
+func (b *Builder) Print() {
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.Log(stackSkipLogger.Error())
+	} else if b.bmerror.Severity == SevWarn {
+		b.bmerror.ShortLog(stackSkipLogger.Warn())
+	}
+
+	b.CallListener(MethodPrint)
+}
+
+func (b *Builder) Format(level LogPrintLevel) string {
+	return b.bmerror.FormatLog(level)
+}
+
+// Fatal prints the error and terminates the program
+// If the error is SevErr we also send it to the error-service
+func (b *Builder) Fatal() {
+	b.bmerror.Severity = SevFatal
+	b.bmerror.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
+
+	b.CallListener(MethodFatal)
+
+	os.Exit(1)
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {
+	b.bmerror.Meta.add(key, mdtype, val)
+	return b
+}
+
+func (b *Builder) toBMError() BMError {
+	return b.bmerror.ToBMError()
+}

exerr/data.go

@@ -0,0 +1,32 @@
+package exerr
+
+type ErrorCategory struct{ Category string }
+
+var (
+	CatWrap    = ErrorCategory{"Wrap"}    // The error is simply wrapping another error (e.g. when a grpc call returns an error)
+	CatSystem  = ErrorCategory{"System"}  // An internal system error (e.g. connection to db failed)
+	CatUser    = ErrorCategory{"User"}    // The user (the API caller) did something wrong (e.g. he has no permissions to do this)
+	CatForeign = ErrorCategory{"Foreign"} // A foreign error that some component threw (e.g. an unknown mongodb error), happens if we call Wrap(..) on an non-bmerror value
+)
+
+var AllCategories = []ErrorCategory{CatWrap, CatSystem, CatUser, CatForeign}
+
+type ErrorSeverity struct{ Severity string }
+
+var (
+	SevTrace = ErrorSeverity{"Trace"}
+	SevDebug = ErrorSeverity{"Debug"}
+	SevInfo  = ErrorSeverity{"Info"}
+	SevWarn  = ErrorSeverity{"Warn"}
+	SevErr   = ErrorSeverity{"Err"}
+	SevFatal = ErrorSeverity{"Fatal"}
+)
+
+var AllSeverities = []ErrorSeverity{SevTrace, SevDebug, SevInfo, SevWarn, SevErr, SevFatal}
+
+type ErrorType struct{ Key string }
+
+var (
+	TypeInternal = ErrorType{"Internal"}
+	// other values come from pkgconfig
+)

exerr/defaults.go

@@ -0,0 +1 @@
+package exerr

exerr/errinit.go

@@ -0,0 +1,50 @@
+package exerr
+
+type ErrorPackageConfig struct {
+	ZeroLogTraces   bool        // autom print zerolog logs on CreateError
+	RecursiveErrors bool        // errors contains their Origin-Error
+	Types           []ErrorType // all available error-types
+}
+
+type ErrorPackageConfigInit struct {
+	LogTraces       bool
+	RecursiveErrors bool
+	InitTypes       func(_ func(_ string) ErrorType)
+}
+
+var initialized = false
+
+var pkgconfig = ErrorPackageConfig{
+	ZeroLogTraces:   true,
+	RecursiveErrors: true,
+	Types:           []ErrorType{TypeInternal},
+}
+
+// Init initializes the exerr packages
+// Must be called at the program start, before (!) any errors
+// Is not thread-safe
+func Init(cfg ErrorPackageConfigInit) {
+	if initialized {
+		panic("Cannot re-init error package")
+	}
+
+	types := pkgconfig.Types
+
+	fnAddType := func(v string) ErrorType {
+		et := ErrorType{v}
+		types = append(types, et)
+		return et
+	}
+
+	if cfg.InitTypes != nil {
+		cfg.InitTypes(fnAddType)
+	}
+
+	pkgconfig = ErrorPackageConfig{
+		ZeroLogTraces:   cfg.LogTraces,
+		RecursiveErrors: cfg.RecursiveErrors,
+		Types:           types,
+	}
+
+	initialized = true
+}

exerr/exerr.go

@@ -0,0 +1,33 @@
+package exerr
+
+import (
+	"time"
+)
+
+type ExErr struct {
+	UniqueID string `json:"uniqueID"`
+
+	Timestamp time.Time     `json:"timestamp"`
+	Category  ErrorCategory `json:"category"`
+	Severity  ErrorSeverity `json:"severity"`
+	Type      ErrorType     `json:"type"`
+
+	Message string `json:"message"`
+	Caller  string `json:"caller"`
+
+	OriginalError *ExErr
+
+	Meta MetaMap `json:"meta"`
+}
+
+func (ee ExErr) Error() string {
+
+}
+
+func (ee ExErr) Unwrap() error {
+
+}
+
+func (ee ExErr) Is(err error) bool {
+
+}

exerr/foreign.go

@@ -0,0 +1,146 @@
+package exerr
+
+import (
+	"bringman.de/common/shared/langext"
+	"encoding/json"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"reflect"
+	"time"
+)
+
+var reflectTypeStr = reflect.TypeOf("")
+
+func getForeignMeta(err error) (mm MetaMap) {
+	mm = make(map[string]MetaValue)
+
+	defer func() {
+		if panicerr := recover(); panicerr != nil {
+			New(ErrPanic, "Panic while trying to get foreign meta").
+				Str("source", err.Error()).
+				Interface("panic-object", panicerr).
+				Stack().
+				Print()
+		}
+	}()
+
+	rval := reflect.ValueOf(err)
+	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Ptr {
+		rval = reflect.ValueOf(err).Elem()
+	}
+
+	mm.add("foreign.errortype", MDTString, rval.Type().String())
+
+	for k, v := range addMetaPrefix("foreign", getReflectedMetaValues(err, 8)) {
+		mm[k] = v
+	}
+
+	return mm
+}
+
+func getReflectedMetaValues(value interface{}, remainingDepth int) map[string]MetaValue {
+
+	if remainingDepth <= 0 {
+		return map[string]MetaValue{}
+	}
+
+	if langext.IsNil(value) {
+		return map[string]MetaValue{"": {DataType: MDTNil, Value: nil}}
+	}
+
+	rval := reflect.ValueOf(value)
+
+	if rval.Type().Kind() == reflect.Ptr {
+
+		if rval.IsNil() {
+			return map[string]MetaValue{"*": {DataType: MDTNil, Value: nil}}
+		}
+
+		elem := rval.Elem()
+
+		return addMetaPrefix("*", getReflectedMetaValues(elem.Interface(), remainingDepth-1))
+	}
+
+	if !rval.CanInterface() {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: "<<no-interface>>"}}
+	}
+
+	raw := rval.Interface()
+
+	switch ifraw := raw.(type) {
+	case time.Time:
+		return map[string]MetaValue{"": {DataType: MDTTime, Value: ifraw}}
+	case time.Duration:
+		return map[string]MetaValue{"": {DataType: MDTDuration, Value: ifraw}}
+	case int:
+		return map[string]MetaValue{"": {DataType: MDTInt, Value: ifraw}}
+	case int8:
+		return map[string]MetaValue{"": {DataType: MDTInt8, Value: ifraw}}
+	case int16:
+		return map[string]MetaValue{"": {DataType: MDTInt16, Value: ifraw}}
+	case int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32, Value: ifraw}}
+	case int64:
+		return map[string]MetaValue{"": {DataType: MDTInt64, Value: ifraw}}
+	case string:
+		return map[string]MetaValue{"": {DataType: MDTString, Value: ifraw}}
+	case bool:
+		return map[string]MetaValue{"": {DataType: MDTBool, Value: ifraw}}
+	case []byte:
+		return map[string]MetaValue{"": {DataType: MDTBytes, Value: ifraw}}
+	case float32:
+		return map[string]MetaValue{"": {DataType: MDTFloat32, Value: ifraw}}
+	case float64:
+		return map[string]MetaValue{"": {DataType: MDTFloat64, Value: ifraw}}
+	case []int:
+		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
+	case []int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
+	case primitive.ObjectID:
+		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
+	case []string:
+		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
+	}
+
+	if rval.Type().Kind() == reflect.Struct {
+		m := make(map[string]MetaValue)
+		for i := 0; i < rval.NumField(); i++ {
+			fieldtype := rval.Type().Field(i)
+
+			fieldname := fieldtype.Name
+
+			if fieldtype.IsExported() {
+				for k, v := range addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)) {
+					m[k] = v
+				}
+			}
+		}
+		return m
+	}
+
+	if rval.Type().ConvertibleTo(reflectTypeStr) {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: rval.Convert(reflectTypeStr).String()}}
+	}
+
+	jsonval, err := json.Marshal(value)
+	if err != nil {
+		panic(err) // gets recovered later up
+	}
+
+	return map[string]MetaValue{"": {DataType: MDTString, Value: string(jsonval)}}
+}
+
+func addMetaPrefix(prefix string, m map[string]MetaValue) map[string]MetaValue {
+	if len(m) == 1 {
+		for k, v := range m {
+			if k == "" {
+				return map[string]MetaValue{prefix: v}
+			}
+		}
+	}
+
+	r := make(map[string]MetaValue, len(m))
+	for k, v := range m {
+		r[prefix+"."+k] = v
+	}
+	return r
+}

exerr/listener.go

@@ -0,0 +1,37 @@
+package exerr
+
+import (
+	"sync"
+)
+
+type Method string
+
+const (
+	MethodOutput Method = "OUTPUT"
+	MethodPrint  Method = "PRINT"
+	MethodBuild  Method = "BUILD"
+	MethodFatal  Method = "FATAL"
+)
+
+type Listener = func(method Method, v ExErr)
+
+var listenerLock = sync.Mutex{}
+var listener = make([]Listener, 0)
+
+func RegisterListener(l Listener) {
+	listenerLock.Lock()
+	defer listenerLock.Unlock()
+
+	listener = append(listener, l)
+}
+
+func (b *Builder) CallListener(m Method) {
+	valErr := b.toBMError()
+
+	listenerLock.Lock()
+	defer listenerLock.Unlock()
+
+	for _, v := range listener {
+		v(m, valErr)
+	}
+}

exerr/meta.go

@@ -0,0 +1,697 @@
+package exerr
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type MetaMap map[string]MetaValue
+
+type metaDataType string
+
+const (
+	MDTString      metaDataType = "String"
+	MDTStringPtr   metaDataType = "StringPtr"
+	MDTInt         metaDataType = "Int"
+	MDTInt8        metaDataType = "Int8"
+	MDTInt16       metaDataType = "Int16"
+	MDTInt32       metaDataType = "Int32"
+	MDTInt64       metaDataType = "Int64"
+	MDTFloat32     metaDataType = "Float32"
+	MDTFloat64     metaDataType = "Float64"
+	MDTBool        metaDataType = "Bool"
+	MDTBytes       metaDataType = "Bytes"
+	MDTObjectID    metaDataType = "ObjectID"
+	MDTTime        metaDataType = "Time"
+	MDTDuration    metaDataType = "Duration"
+	MDTStringArray metaDataType = "StringArr"
+	MDTIntArray    metaDataType = "IntArr"
+	MDTInt32Array  metaDataType = "Int32Arr"
+	MDTID          metaDataType = "ID"
+	MDTAny         metaDataType = "Interface"
+	MDTNil         metaDataType = "Nil"
+)
+
+type MetaValue struct {
+	DataType metaDataType `json:"dataType"`
+	Value    interface{}  `json:"value"`
+}
+
+type metaValueSerialization struct {
+	DataType metaDataType `bson:"dataType"`
+	Value    string       `bson:"value"`
+	Raw      interface{}  `bson:"raw"`
+}
+
+func (v MetaValue) SerializeValue() (string, error) {
+	switch v.DataType {
+	case MDTString:
+		return v.Value.(string), nil
+	case MDTID:
+		return v.Value.(IDWrap).Serialize(), nil
+	case MDTAny:
+		return v.Value.(AnyWrap).Serialize(), nil
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r := v.Value.(*string)
+		if r != nil {
+			return "*" + *r, nil
+		} else {
+			return "#", nil
+		}
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int)), nil
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10), nil
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10), nil
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10), nil
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10), nil
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'X', -1, 32), nil
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'X', -1, 64), nil
+	case MDTBool:
+		if v.Value.(bool) {
+			return "true", nil
+		} else {
+			return "false", nil
+		}
+	case MDTBytes:
+		return hex.EncodeToString(v.Value.([]byte)), nil
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex(), nil
+	case MDTTime:
+		return strconv.FormatInt(v.Value.(time.Time).Unix(), 10) + "|" + strconv.FormatInt(int64(v.Value.(time.Time).Nanosecond()), 10), nil
+	case MDTDuration:
+		return v.Value.(time.Duration).String(), nil
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]string))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]int))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]int32))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTNil:
+		return "", nil
+	}
+	return "", errors.New("Unknown type: " + string(v.DataType))
+}
+
+func (v MetaValue) ShortString(lim int) string {
+	switch v.DataType {
+	case MDTString:
+		r := strings.ReplaceAll(v.Value.(string), "\r", "")
+		r = strings.ReplaceAll(r, "\n", "\\n")
+		r = strings.ReplaceAll(r, "\t", "\\t")
+		return langext.StrLimit(r, lim, "...")
+	case MDTID:
+		return v.Value.(IDWrap).String()
+	case MDTAny:
+		return v.Value.(AnyWrap).String()
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r := langext.CoalesceString(v.Value.(*string), "<<null>>")
+		r = strings.ReplaceAll(r, "\r", "")
+		r = strings.ReplaceAll(r, "\n", "\\n")
+		r = strings.ReplaceAll(r, "\t", "\\t")
+		return langext.StrLimit(r, lim, "...")
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int))
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10)
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10)
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10)
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10)
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'g', 4, 32)
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'g', 4, 64)
+	case MDTBool:
+		return fmt.Sprintf("%v", v.Value.(bool))
+	case MDTBytes:
+		return langext.StrLimit(hex.EncodeToString(v.Value.([]byte)), lim, "...")
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex()
+	case MDTTime:
+		return v.Value.(time.Time).Format(time.RFC3339)
+	case MDTDuration:
+		return v.Value.(time.Duration).String()
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]string))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]int))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]int32))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTNil:
+		return "<<null>>"
+	}
+	return "(err)"
+}
+
+func (v MetaValue) Apply(key string, evt *zerolog.Event) *zerolog.Event {
+	switch v.DataType {
+	case MDTString:
+		return evt.Str(key, v.Value.(string))
+	case MDTID:
+		return evt.Str(key, v.Value.(IDWrap).Value)
+	case MDTAny:
+		if v.Value.(AnyWrap).IsError {
+			return evt.Str(key, "(err)")
+		} else {
+			return evt.Str(key, v.Value.(AnyWrap).Json)
+		}
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return evt.Str(key, "<<null>>")
+		}
+		return evt.Str(key, langext.CoalesceString(v.Value.(*string), "<<null>>"))
+	case MDTInt:
+		return evt.Int(key, v.Value.(int))
+	case MDTInt8:
+		return evt.Int8(key, v.Value.(int8))
+	case MDTInt16:
+		return evt.Int16(key, v.Value.(int16))
+	case MDTInt32:
+		return evt.Int32(key, v.Value.(int32))
+	case MDTInt64:
+		return evt.Int64(key, v.Value.(int64))
+	case MDTFloat32:
+		return evt.Float32(key, v.Value.(float32))
+	case MDTFloat64:
+		return evt.Float64(key, v.Value.(float64))
+	case MDTBool:
+		return evt.Bool(key, v.Value.(bool))
+	case MDTBytes:
+		return evt.Bytes(key, v.Value.([]byte))
+	case MDTObjectID:
+		return evt.Str(key, v.Value.(primitive.ObjectID).Hex())
+	case MDTTime:
+		return evt.Time(key, v.Value.(time.Time))
+	case MDTDuration:
+		return evt.Dur(key, v.Value.(time.Duration))
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return evt.Strs(key, nil)
+		}
+		return evt.Strs(key, v.Value.([]string))
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return evt.Ints(key, nil)
+		}
+		return evt.Ints(key, v.Value.([]int))
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return evt.Ints32(key, nil)
+		}
+		return evt.Ints32(key, v.Value.([]int32))
+	case MDTNil:
+		return evt.Str(key, "<<null>>")
+	}
+	return evt.Str(key, "(err)")
+}
+
+func (v MetaValue) MarshalJSON() ([]byte, error) {
+	str, err := v.SerializeValue()
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(string(v.DataType) + ":" + str)
+}
+
+func (v *MetaValue) UnmarshalJSON(data []byte) error {
+	var str = ""
+	err := json.Unmarshal(data, &str)
+	if err != nil {
+		return err
+	}
+
+	split := strings.SplitN(str, ":", 2)
+	if len(split) != 2 {
+		return errors.New("failed to decode MetaValue: '" + str + "'")
+	}
+
+	return v.Deserialize(split[1], metaDataType(split[0]))
+}
+
+func (v MetaValue) MarshalBSON() ([]byte, error) {
+	serval, err := v.SerializeValue()
+	if err != nil {
+		return nil, Wrap(err, "failed to bson-marshal MetaValue (serialize)").Build()
+	}
+
+	// this is an kinda ugly hack - but serialization to mongodb and back can loose the correct type information....
+	bin, err := bson.Marshal(metaValueSerialization{
+		DataType: v.DataType,
+		Value:    serval,
+		Raw:      v.Value,
+	})
+	if err != nil {
+		return nil, Wrap(err, "failed to bson-marshal MetaValue (marshal)").Build()
+	}
+
+	return bin, nil
+}
+
+func (v *MetaValue) UnmarshalBSON(bytes []byte) error {
+	var serval metaValueSerialization
+	err := bson.Unmarshal(bytes, &serval)
+	if err != nil {
+		return Wrap(err, "failed to bson-unmarshal MetaValue (unmarshal)").Build()
+	}
+
+	err = v.Deserialize(serval.Value, serval.DataType)
+	if err != nil {
+		return Wrap(err, "failed to deserialize MetaValue from bson").Str("raw", serval.Value).Build()
+	}
+
+	return nil
+}
+
+func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
+	switch datatype {
+	case MDTString:
+		v.Value = value
+		v.DataType = datatype
+		return nil
+	case MDTID:
+		v.Value = deserializeIDWrap(value)
+		v.DataType = datatype
+		return nil
+	case MDTAny:
+		v.Value = deserializeAnyWrap(value)
+		v.DataType = datatype
+		return nil
+	case MDTStringPtr:
+		if len(value) <= 0 || (value[0] != '*' && value[0] != '#') {
+			return errors.New("Invalid StringPtr: " + value)
+		} else if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		} else {
+			r, err := valueFromProto(value[1:], MDTString)
+			if err != nil {
+				return err
+			}
+			v.Value = langext.Ptr(r.Value.(string))
+			v.DataType = datatype
+			return nil
+		}
+	case MDTInt:
+		pv, err := strconv.ParseInt(value, 10, 0)
+		if err != nil {
+			return err
+		}
+		v.Value = int(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt8:
+		pv, err := strconv.ParseInt(value, 10, 8)
+		if err != nil {
+			return err
+		}
+		v.Value = int8(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt16:
+		pv, err := strconv.ParseInt(value, 10, 16)
+		if err != nil {
+			return err
+		}
+		v.Value = int16(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt32:
+		pv, err := strconv.ParseInt(value, 10, 32)
+		if err != nil {
+			return err
+		}
+		v.Value = int32(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt64:
+		pv, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = pv
+		v.DataType = datatype
+		return nil
+	case MDTFloat32:
+		pv, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = float32(pv)
+		v.DataType = datatype
+		return nil
+	case MDTFloat64:
+		pv, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = pv
+		v.DataType = datatype
+		return nil
+	case MDTBool:
+		if value == "true" {
+			v.Value = true
+			v.DataType = datatype
+			return nil
+		}
+		if value == "false" {
+			v.Value = false
+			v.DataType = datatype
+			return nil
+		}
+		return errors.New("invalid bool value: " + value)
+	case MDTBytes:
+		r, err := hex.DecodeString(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTObjectID:
+		r, err := primitive.ObjectIDFromHex(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTTime:
+		ps := strings.Split(value, "|")
+		if len(ps) != 2 {
+			return errors.New("invalid time.time: " + value)
+		}
+		p1, err := strconv.ParseInt(ps[0], 10, 64)
+		if err != nil {
+			return err
+		}
+		p2, err := strconv.ParseInt(ps[1], 10, 32)
+		if err != nil {
+			return err
+		}
+		v.Value = time.Unix(p1, p2)
+		v.DataType = datatype
+		return nil
+	case MDTDuration:
+		r, err := time.ParseDuration(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTStringArray:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]string, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTIntArray:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]int, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTInt32Array:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]int32, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTNil:
+		v.Value = nil
+		v.DataType = datatype
+		return nil
+	}
+	return errors.New("Unknown type: " + string(datatype))
+}
+
+func (v MetaValue) ValueString() string {
+	switch v.DataType {
+	case MDTString:
+		return v.Value.(string)
+	case MDTID:
+		return v.Value.(IDWrap).String()
+	case MDTAny:
+		return v.Value.(AnyWrap).String()
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		return langext.CoalesceString(v.Value.(*string), "<<null>>")
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int))
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10)
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10)
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10)
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10)
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'g', 4, 32)
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'g', 4, 64)
+	case MDTBool:
+		return fmt.Sprintf("%v", v.Value.(bool))
+	case MDTBytes:
+		return hex.EncodeToString(v.Value.([]byte))
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex()
+	case MDTTime:
+		return v.Value.(time.Time).Format(time.RFC3339Nano)
+	case MDTDuration:
+		return v.Value.(time.Duration).String()
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]string), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		return string(r)
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]int), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		return string(r)
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]int32), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		return string(r)
+	case MDTNil:
+		return "<<null>>"
+	}
+	return "(err)"
+}
+
+func valueFromProto(value string, datatype metaDataType) (MetaValue, error) {
+	obj := MetaValue{}
+	err := obj.Deserialize(value, datatype)
+	if err != nil {
+		return MetaValue{}, err
+	}
+	return obj, nil
+}
+
+func metaFromProto(proto []*spbmodels.CustomError_MetaValue) MetaMap {
+	r := make(MetaMap)
+
+	for _, v := range proto {
+		mval, err := valueFromProto(v.Value, metaDataType(v.Type))
+		if err != nil {
+			log.Warn().Err(err).Msg("metaFromProto failed for " + v.Key)
+			continue
+		}
+		r[v.Key] = mval
+	}
+
+	return r
+}
+
+func (mm MetaMap) ToProto() []*spbmodels.CustomError_MetaValue {
+	if mm == nil {
+		return make([]*spbmodels.CustomError_MetaValue, 0)
+	}
+	r := make([]*spbmodels.CustomError_MetaValue, 0, len(mm))
+	for k, v := range mm {
+		strval, err := v.SerializeValue()
+		if err != nil {
+			log.Warn().Err(err).Msg("MetaMap.ToProto failed for " + k)
+			continue
+		}
+
+		r = append(r, &spbmodels.CustomError_MetaValue{
+			Key:   k,
+			Type:  string(v.DataType),
+			Value: strval,
+		})
+	}
+	return r
+}
+
+func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
+	r := ""
+
+	i := 0
+	for key, val := range mm {
+		if i > 0 {
+			r += ", "
+		}
+
+		r += "\"" + key + "\""
+		r += ": "
+		r += "\"" + val.ShortString(singleMaxLen) + "\""
+
+		i++
+	}
+
+	return r
+}
+
+func (mm MetaMap) FormatMultiLine(indentFront string, indentKeys string, maxLenValue int) string {
+	r := ""
+
+	r += indentFront + "{" + "\n"
+	for key, val := range mm {
+		if key == "gin.body" {
+			continue
+		}
+
+		r += indentFront
+		r += indentKeys
+		r += "\"" + key + "\""
+		r += ": "
+		r += "\"" + val.ShortString(maxLenValue) + "\""
+		r += ",\n"
+	}
+	r += indentFront + "}"
+
+	return r
+}
+
+func (mm MetaMap) Any() bool {
+	return len(mm) > 0
+}
+
+func (mm MetaMap) Apply(evt *zerolog.Event) *zerolog.Event {
+	for key, val := range mm {
+		evt = val.Apply(key, evt)
+	}
+	return evt
+}
+
+func (mm MetaMap) add(key string, mdtype metaDataType, val interface{}) {
+	if _, ok := mm[key]; !ok {
+		mm[key] = MetaValue{DataType: mdtype, Value: val}
+		return
+	}
+	for i := 2; ; i++ {
+		realkey := key + "-" + strconv.Itoa(i)
+		if _, ok := mm[realkey]; !ok {
+			mm[realkey] = MetaValue{DataType: mdtype, Value: val}
+			return
+		}
+	}
+}

exerr/stacktrace.go

@@ -0,0 +1,14 @@
+package exerr
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func callername(skip int) string {
+	pc := make([]uintptr, 15)
+	n := runtime.Callers(skip+2, pc)
+	frames := runtime.CallersFrames(pc[:n])
+	frame, _ := frames.Next()
+	return fmt.Sprintf("%s:%d %s", frame.File, frame.Line, frame.Function)
+}

exerr/wrapper.go

@@ -0,0 +1,133 @@
+package exerr
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog/log"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"strings"
+)
+
+//
+// These are wrapper objects, because for some metadata-types we need to serialize a bit more complex data
+// (eg thy actual type for ID objects, or the json representation for any types)
+//
+
+type IDWrap struct {
+	Type  string
+	Value string
+	IsNil bool
+}
+
+func newIDWrap(val fmt.Stringer) IDWrap {
+	t := fmt.Sprintf("%T", val)
+	arr := strings.Split(t, ".")
+	if len(arr) > 0 {
+		t = arr[len(arr)-1]
+	}
+
+	if langext.IsNil(val) {
+		return IDWrap{Type: t, Value: "", IsNil: true}
+	}
+
+	v := val.String()
+	return IDWrap{Type: t, Value: v, IsNil: false}
+}
+
+func (w IDWrap) Serialize() string {
+	if w.IsNil {
+		return "!nil" + ":" + w.Type
+	}
+	return w.Type + ":" + w.Value
+}
+
+func (w IDWrap) String() string {
+	if w.IsNil {
+		return w.Type + "<<nil>>"
+	}
+	return w.Type + "(" + w.Value + ")"
+}
+
+func deserializeIDWrap(v string) IDWrap {
+	r := strings.SplitN(v, ":", 2)
+
+	if len(r) == 2 && r[0] == "!nil" {
+		return IDWrap{Type: r[1], Value: v, IsNil: true}
+	}
+
+	if len(r) == 0 {
+		return IDWrap{}
+	} else if len(r) == 1 {
+		return IDWrap{Type: "", Value: v, IsNil: false}
+	} else {
+		return IDWrap{Type: r[0], Value: r[1], IsNil: false}
+	}
+}
+
+type AnyWrap struct {
+	Type    string
+	Json    string
+	IsError bool
+	IsNil   bool
+}
+
+func newAnyWrap(val any) (result AnyWrap) {
+	result = AnyWrap{Type: "", Json: "", IsError: true, IsNil: false} // ensure a return in case of recover()
+
+	defer func() {
+		if err := recover(); err != nil {
+			// send error should never crash our program
+			log.Error().Interface("err", err).Msg("Panic while trying to marshal anywrap ( bmerror.Interface )")
+		}
+	}()
+
+	t := fmt.Sprintf("%T", val)
+
+	if langext.IsNil(val) {
+		return AnyWrap{Type: t, Json: "", IsError: false, IsNil: true}
+	}
+
+	j, err := json.Marshal(val)
+	if err == nil {
+		return AnyWrap{Type: t, Json: string(j), IsError: false, IsNil: false}
+	} else {
+		return AnyWrap{Type: t, Json: "", IsError: true, IsNil: false}
+	}
+}
+
+func (w AnyWrap) Serialize() string {
+	if w.IsError {
+		return "ERR" + ":" + w.Type + ":" + w.Json
+	} else if w.IsNil {
+		return "NIL" + ":" + w.Type + ":" + w.Json
+	} else {
+		return "OK" + ":" + w.Type + ":" + w.Json
+	}
+}
+
+func (w AnyWrap) String() string {
+	if w.IsError {
+		return "(error)"
+	} else if w.IsNil {
+		return "(nil)"
+	} else {
+		return w.Json
+	}
+}
+
+func deserializeAnyWrap(v string) AnyWrap {
+	r := strings.SplitN(v, ":", 3)
+	if len(r) != 3 {
+		return AnyWrap{IsError: true, Type: "", Json: "", IsNil: false}
+	} else {
+		if r[0] == "OK" {
+			return AnyWrap{IsError: false, Type: r[1], Json: r[2], IsNil: false}
+		} else if r[0] == "ERR" {
+			return AnyWrap{IsError: true, Type: r[1], Json: r[2], IsNil: false}
+		} else if r[0] == "NIL" {
+			return AnyWrap{IsError: false, Type: r[1], Json: "", IsNil: true}
+		} else {
+			return AnyWrap{IsError: true, Type: "", Json: "", IsNil: false}
+		}
+	}
+}

go.mod

@@ -3,12 +3,25 @@ module gogs.mikescher.com/BlackForestBytes/goext
 go 1.19
 
 require (
-	golang.org/x/sys v0.3.0
+	golang.org/x/sys v0.5.0
 	golang.org/x/term v0.3.0
 )
 
 require (
+	github.com/golang/snappy v0.0.1 // indirect
 	github.com/jmoiron/sqlx v1.3.5 // indirect
-	go.mongodb.org/mongo-driver v1.11.1 // indirect
+	github.com/klauspost/compress v1.13.6 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rs/zerolog v1.29.0 // indirect
+	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
+	github.com/xdg-go/scram v1.1.1 // indirect
+	github.com/xdg-go/stringprep v1.0.3 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
+	go.mongodb.org/mongo-driver v1.11.2 // indirect
 	golang.org/x/crypto v0.4.0 // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/text v0.5.0 // indirect
 )

go.sum

@@ -1,40 +1,66 @@
+github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
 github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
+github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0=
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w=
+github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg-go/scram v1.1.1 h1:VOMT+81stJgXW3CpHyqHN3AXDYIMsx56mEFrB37Mb/E=
 github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
+github.com/xdg-go/stringprep v1.0.3 h1:kdwGpVNwPFtjs98xCGkHjQtGKh86rDcRZN17QEMCOIs=
 github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
-go.mongodb.org/mongo-driver v1.11.1 h1:QP0znIRTuL0jf1oBQoAoM0C6ZJfBK4kx0Uumtv1A7w8=
-go.mongodb.org/mongo-driver v1.11.1/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
+go.mongodb.org/mongo-driver v1.11.2 h1:+1v2rDQUWNcGW7/7E0Jvdz51V38XXxJfhzbV17aNHCw=
+go.mongodb.org/mongo-driver v1.11.2/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 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/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 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/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.1.0 h1:g6Z6vPFA9dYBAF7DWcH6sCcOntplXsDKcliusYijMlw=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -42,6 +68,8 @@ golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
 golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

langext/array.go

@@ -265,26 +265,6 @@ func ArrMap[T1 any, T2 any](arr []T1, conv func(v T1) T2) []T2 {
 	return r
 }
 
-func ArrMapExt[T1 any, T2 any](arr []T1, conv func(idx int, v T1) T2) []T2 {
-	r := make([]T2, len(arr))
-	for i, v := range arr {
-		r[i] = conv(i, v)
-	}
-	return r
-}
-
-func ArrMapErr[T1 any, T2 any](arr []T1, conv func(v T1) (T2, error)) ([]T2, error) {
-	var err error
-	r := make([]T2, len(arr))
-	for i, v := range arr {
-		r[i], err = conv(v)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return r, nil
-}
-
 func ArrFilterMap[T1 any, T2 any](arr []T1, filter func(v T1) bool, conv func(v T1) T2) []T2 {
 	r := make([]T2, 0, len(arr))
 	for _, v := range arr {
@@ -295,16 +275,6 @@ func ArrFilterMap[T1 any, T2 any](arr []T1, filter func(v T1) bool, conv func(v
 	return r
 }
 
-func ArrFilter[T any](arr []T, filter func(v T) bool) []T {
-	r := make([]T, 0, len(arr))
-	for _, v := range arr {
-		if filter(v) {
-			r = append(r, v)
-		}
-	}
-	return r
-}
-
 func ArrSum[T NumberConstraint](arr []T) T {
 	var r T = 0
 	for _, v := range arr {
@@ -313,18 +283,10 @@ func ArrSum[T NumberConstraint](arr []T) T {
 	return r
 }
 
-func ArrFlatten[T1 any, T2 any](arr []T1, conv func(v T1) []T2) []T2 {
-	r := make([]T2, 0, len(arr))
-	for _, v1 := range arr {
-		r = append(r, conv(v1)...)
+func ArrRemove[T comparable](arr []T, needle T) []T {
+	idx := ArrFirstIndex(arr, needle)
+	if idx >= 0 {
+		return append(arr[:idx], arr[idx+1:]...)
 	}
-	return r
-}
-
-func ArrFlattenDirect[T1 any](arr [][]T1) []T1 {
-	r := make([]T1, 0, len(arr))
-	for _, v1 := range arr {
-		r = append(r, v1...)
-	}
-	return r
+	return arr
 }

langext/base58.go

@@ -1,178 +0,0 @@
-package langext
-
-import (
-	"bytes"
-	"errors"
-	"math/big"
-)
-
-// shamelessly stolen from https://github.com/btcsuite/
-
-type B58Encoding struct {
-	bigRadix     [11]*big.Int
-	bigRadix10   *big.Int
-	alphabet     string
-	alphabetIdx0 byte
-	b58          [256]byte
-}
-
-var Base58DefaultEncoding = newBase58Encoding("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
-var Base58FlickrEncoding = newBase58Encoding("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")
-var Base58RippleEncoding = newBase58Encoding("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz")
-var Base58BitcoinEncoding = newBase58Encoding("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
-
-func newBase58Encoding(alphabet string) *B58Encoding {
-	bigRadix10 := big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58)
-	enc := &B58Encoding{
-		alphabet:     alphabet,
-		alphabetIdx0: '1',
-		bigRadix: [...]*big.Int{
-			big.NewInt(0),
-			big.NewInt(58),
-			big.NewInt(58 * 58),
-			big.NewInt(58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
-			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
-			bigRadix10,
-		},
-		bigRadix10: bigRadix10,
-	}
-
-	b58 := make([]byte, 0, 256)
-
-	for i := byte(0); i < 32; i++ {
-		for j := byte(0); j < 8; j++ {
-
-			b := i*8 + j
-
-			idx := bytes.IndexByte([]byte(alphabet), b)
-			if idx == -1 {
-				b58 = append(b58, 255)
-			} else {
-				b58 = append(b58, byte(idx))
-			}
-
-		}
-	}
-
-	enc.b58 = *((*[256]byte)(b58))
-
-	return enc
-}
-
-func (enc *B58Encoding) EncodeString(src string) (string, error) {
-	v, err := enc.Encode([]byte(src))
-	if err != nil {
-		return "", err
-	}
-	return string(v), nil
-}
-
-func (enc *B58Encoding) Encode(src []byte) ([]byte, error) {
-	x := new(big.Int)
-	x.SetBytes(src)
-
-	// maximum length of output is log58(2^(8*len(b))) == len(b) * 8 / log(58)
-	maxlen := int(float64(len(src))*1.365658237309761) + 1
-	answer := make([]byte, 0, maxlen)
-	mod := new(big.Int)
-	for x.Sign() > 0 {
-		// Calculating with big.Int is slow for each iteration.
-		//    x, mod = x / 58, x % 58
-		//
-		// Instead we can try to do as much calculations on int64.
-		//    x, mod = x / 58^10, x % 58^10
-		//
-		// Which will give us mod, which is 10 digit base58 number.
-		// We'll loop that 10 times to convert to the answer.
-
-		x.DivMod(x, enc.bigRadix10, mod)
-		if x.Sign() == 0 {
-			// When x = 0, we need to ensure we don't add any extra zeros.
-			m := mod.Int64()
-			for m > 0 {
-				answer = append(answer, enc.alphabet[m%58])
-				m /= 58
-			}
-		} else {
-			m := mod.Int64()
-			for i := 0; i < 10; i++ {
-				answer = append(answer, enc.alphabet[m%58])
-				m /= 58
-			}
-		}
-	}
-
-	// leading zero bytes
-	for _, i := range src {
-		if i != 0 {
-			break
-		}
-		answer = append(answer, enc.alphabetIdx0)
-	}
-
-	// reverse
-	alen := len(answer)
-	for i := 0; i < alen/2; i++ {
-		answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i]
-	}
-
-	return answer, nil
-}
-
-func (enc *B58Encoding) DecodeString(src string) (string, error) {
-	v, err := enc.Decode([]byte(src))
-	if err != nil {
-		return "", err
-	}
-	return string(v), nil
-}
-
-func (enc *B58Encoding) Decode(src []byte) ([]byte, error) {
-	answer := big.NewInt(0)
-	scratch := new(big.Int)
-
-	for t := src; len(t) > 0; {
-		n := len(t)
-		if n > 10 {
-			n = 10
-		}
-
-		total := uint64(0)
-		for _, v := range t[:n] {
-			if v > 255 {
-				return []byte{}, errors.New("invalid char in input")
-			}
-
-			tmp := enc.b58[v]
-			if tmp == 255 {
-				return []byte{}, errors.New("invalid char in input")
-			}
-			total = total*58 + uint64(tmp)
-		}
-
-		answer.Mul(answer, enc.bigRadix[n])
-		scratch.SetUint64(total)
-		answer.Add(answer, scratch)
-
-		t = t[n:]
-	}
-
-	tmpval := answer.Bytes()
-
-	var numZeros int
-	for numZeros = 0; numZeros < len(src); numZeros++ {
-		if src[numZeros] != enc.alphabetIdx0 {
-			break
-		}
-	}
-	flen := numZeros + len(tmpval)
-	val := make([]byte, flen)
-	copy(val[numZeros:], tmpval)
-
-	return val, nil
-}

langext/base58_test.go

@@ -1,67 +0,0 @@
-package langext
-
-import (
-	"testing"
-)
-
-func _encStr(t *testing.T, enc *B58Encoding, v string) string {
-	v, err := enc.EncodeString(v)
-	if err != nil {
-		t.Error(err)
-	}
-	return v
-}
-
-func _decStr(t *testing.T, enc *B58Encoding, v string) string {
-	v, err := enc.DecodeString(v)
-	if err != nil {
-		t.Error(err)
-	}
-	return v
-}
-
-func TestBase58DefaultEncoding(t *testing.T) {
-	assertEqual(t, _encStr(t, Base58DefaultEncoding, "Hello"), "9Ajdvzr")
-	assertEqual(t, _encStr(t, Base58DefaultEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX")
-}
-
-func TestBase58DefaultDecoding(t *testing.T) {
-	assertEqual(t, _decStr(t, Base58DefaultEncoding, "9Ajdvzr"), "Hello")
-	assertEqual(t, _decStr(t, Base58DefaultEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.")
-}
-
-func TestBase58RippleEncoding(t *testing.T) {
-	assertEqual(t, _encStr(t, Base58RippleEncoding, "Hello"), "9wjdvzi")
-	assertEqual(t, _encStr(t, Base58RippleEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX")
-}
-
-func TestBase58RippleDecoding(t *testing.T) {
-	assertEqual(t, _decStr(t, Base58RippleEncoding, "9wjdvzi"), "Hello")
-	assertEqual(t, _decStr(t, Base58RippleEncoding, "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.")
-}
-
-func TestBase58BitcoinEncoding(t *testing.T) {
-	assertEqual(t, _encStr(t, Base58BitcoinEncoding, "Hello"), "9Ajdvzr")
-	assertEqual(t, _encStr(t, Base58BitcoinEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX")
-}
-
-func TestBase58BitcoinDecoding(t *testing.T) {
-	assertEqual(t, _decStr(t, Base58BitcoinEncoding, "9Ajdvzr"), "Hello")
-	assertEqual(t, _decStr(t, Base58BitcoinEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.")
-}
-
-func TestBase58FlickrEncoding(t *testing.T) {
-	assertEqual(t, _encStr(t, Base58FlickrEncoding, "Hello"), "9aJCVZR")
-	assertEqual(t, _encStr(t, Base58FlickrEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw")
-}
-
-func TestBase58FlickrDecoding(t *testing.T) {
-	assertEqual(t, _decStr(t, Base58FlickrEncoding, "9aJCVZR"), "Hello")
-	assertEqual(t, _decStr(t, Base58FlickrEncoding, "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.")
-}
-
-func assertEqual(t *testing.T, actual string, expected string) {
-	if actual != expected {
-		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
-	}
-}

rfctime/interface.go

@@ -3,52 +3,6 @@ package rfctime
 import "time"
 
 type RFCTime interface {
-	AnyTime
-
-	Time() time.Time
-	Serialize() string
-
-	After(u AnyTime) bool
-	Before(u AnyTime) bool
-	Equal(u AnyTime) bool
-
-	Sub(u AnyTime) time.Duration
-}
-
-type AnyTime interface {
-	MarshalJSON() ([]byte, error)
-
-	MarshalBinary() ([]byte, error)
-
-	GobEncode() ([]byte, error)
-
-	MarshalText() ([]byte, error)
-
-	IsZero() bool
-	Date() (year int, month time.Month, day int)
-	Year() int
-	Month() time.Month
-	Day() int
-	Weekday() time.Weekday
-	ISOWeek() (year, week int)
-	Clock() (hour, min, sec int)
-	Hour() int
-	Minute() int
-	Second() int
-	Nanosecond() int
-	YearDay() int
-	Unix() int64
-	UnixMilli() int64
-	UnixMicro() int64
-	UnixNano() int64
-	Format(layout string) string
-	GoString() string
-	String() string
-
-	Location() *time.Location
-}
-
-type RFCDuration interface {
 	Time() time.Time
 	Serialize() string
 
@@ -64,9 +18,9 @@ type RFCDuration interface {
 	MarshalText() ([]byte, error)
 	UnmarshalText(data []byte) error
 
-	After(u AnyTime) bool
-	Before(u AnyTime) bool
-	Equal(u AnyTime) bool
+	After(u RFCTime) bool
+	Before(u RFCTime) bool
+	Equal(u RFCTime) bool
 	IsZero() bool
 	Date() (year int, month time.Month, day int)
 	Year() int
@@ -80,7 +34,7 @@ type RFCDuration interface {
 	Second() int
 	Nanosecond() int
 	YearDay() int
-	Sub(u AnyTime) time.Duration
+	Sub(u RFCTime) time.Duration
 	Unix() int64
 	UnixMilli() int64
 	UnixMicro() int64
@@ -89,13 +43,3 @@ type RFCDuration interface {
 	GoString() string
 	String() string
 }
-
-func tt(v AnyTime) time.Time {
-	if r, ok := v.(time.Time); ok {
-		return r
-	}
-	if r, ok := v.(RFCTime); ok {
-		return r.Time()
-	}
-	return time.Unix(0, v.UnixNano()).In(v.Location())
-}

rfctime/interface_test.go

@@ -1,50 +0,0 @@
-package rfctime
-
-import (
-	"testing"
-	"time"
-)
-
-func TestAnyTimeInterface(t *testing.T) {
-
-	var v AnyTime
-
-	v = NowRFC3339Nano()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowRFC3339()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnix()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnixMilli()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnixNano()
-	assertEqual(t, v.String(), v.String())
-
-	v = time.Now()
-	assertEqual(t, v.String(), v.String())
-
-}
-
-func TestRFCTimeInterface(t *testing.T) {
-	var v RFCTime
-
-	v = NowRFC3339Nano()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowRFC3339()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnix()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnixMilli()
-	assertEqual(t, v.String(), v.String())
-
-	v = NowUnixNano()
-	assertEqual(t, v.String(), v.String())
-
-}

rfctime/rfc3339.go

@@ -2,10 +2,6 @@ package rfctime
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"time"
 )
 
@@ -65,23 +61,6 @@ func (t *RFC3339Time) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt != bsontype.DateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339Time", bt))
-	}
-	var tt time.Time
-	err := bson.Unmarshal(data, &tt)
-	if err != nil {
-		return err
-	}
-	*t = RFC3339Time(tt)
-	return nil
-}
-
-func (t RFC3339Time) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
-}
-
 func (t RFC3339Time) Serialize() string {
 	return t.Time().Format(t.FormatStr())
 }
@@ -90,16 +69,16 @@ func (t RFC3339Time) FormatStr() string {
 	return time.RFC3339
 }
 
-func (t RFC3339Time) After(u AnyTime) bool {
-	return t.Time().After(tt(u))
+func (t RFC3339Time) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
 }
 
-func (t RFC3339Time) Before(u AnyTime) bool {
-	return t.Time().Before(tt(u))
+func (t RFC3339Time) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
 }
 
-func (t RFC3339Time) Equal(u AnyTime) bool {
-	return t.Time().Equal(tt(u))
+func (t RFC3339Time) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
 }
 
 func (t RFC3339Time) IsZero() bool {
@@ -158,8 +137,8 @@ func (t RFC3339Time) Add(d time.Duration) RFC3339Time {
 	return RFC3339Time(t.Time().Add(d))
 }
 
-func (t RFC3339Time) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(tt(u))
+func (t RFC3339Time) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
 }
 
 func (t RFC3339Time) AddDate(years int, months int, days int) RFC3339Time {
@@ -194,10 +173,6 @@ func (t RFC3339Time) String() string {
 	return t.Time().String()
 }
 
-func (t RFC3339Time) Location() *time.Location {
-	return t.Time().Location()
-}
-
 func NewRFC3339(t time.Time) RFC3339Time {
 	return RFC3339Time(t)
 }

rfctime/rfc3339Nano.go

@@ -2,10 +2,6 @@ package rfctime
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"time"
 )
 
@@ -65,23 +61,6 @@ func (t *RFC3339NanoTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt != bsontype.DateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
-	}
-	var tt time.Time
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
-	if err != nil {
-		return err
-	}
-	*t = RFC3339NanoTime(tt)
-	return nil
-}
-
-func (t RFC3339NanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
-}
-
 func (t RFC3339NanoTime) Serialize() string {
 	return t.Time().Format(t.FormatStr())
 }
@@ -90,16 +69,16 @@ func (t RFC3339NanoTime) FormatStr() string {
 	return time.RFC3339Nano
 }
 
-func (t RFC3339NanoTime) After(u AnyTime) bool {
-	return t.Time().After(tt(u))
+func (t RFC3339NanoTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
 }
 
-func (t RFC3339NanoTime) Before(u AnyTime) bool {
-	return t.Time().Before(tt(u))
+func (t RFC3339NanoTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
 }
 
-func (t RFC3339NanoTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(tt(u))
+func (t RFC3339NanoTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
 }
 
 func (t RFC3339NanoTime) IsZero() bool {
@@ -158,8 +137,8 @@ func (t RFC3339NanoTime) Add(d time.Duration) RFC3339NanoTime {
 	return RFC3339NanoTime(t.Time().Add(d))
 }
 
-func (t RFC3339NanoTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(tt(u))
+func (t RFC3339NanoTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
 }
 
 func (t RFC3339NanoTime) AddDate(years int, months int, days int) RFC3339NanoTime {
@@ -194,10 +173,6 @@ func (t RFC3339NanoTime) String() string {
 	return t.Time().String()
 }
 
-func (t RFC3339NanoTime) Location() *time.Location {
-	return t.Time().Location()
-}
-
 func NewRFC3339Nano(t time.Time) RFC3339NanoTime {
 	return RFC3339NanoTime(t)
 }

rfctime/rfc3339Nano_test.go

@@ -12,7 +12,7 @@ func TestRoundtrip(t *testing.T) {
 		Value RFC3339NanoTime `json:"v"`
 	}
 
-	val1 := NewRFC3339Nano(time.Unix(0, 1675951556820915171))
+	val1 := NewRFC3339Nano(time.Now())
 	w1 := Wrap{val1}
 
 	jstr1, err := json.Marshal(w1)
@@ -20,8 +20,7 @@ func TestRoundtrip(t *testing.T) {
 		panic(err)
 	}
 
-	if string(jstr1) != "{\"v\":\"2023-02-09T15:05:56.820915171+01:00\"}" {
-		t.Errorf(string(jstr1))
+	if string(jstr1) != "{\"v\":\"2023-01-29T20:32:36.149692117+01:00\"}" {
 		t.Errorf("repr differs")
 	}
 

rfctime/seconds.go

@@ -1,59 +0,0 @@
-package rfctime
-
-import (
-	"encoding/json"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
-	"time"
-)
-
-type SecondsF64 time.Duration
-
-func (d SecondsF64) Duration() time.Duration {
-	return time.Duration(d)
-}
-
-func (d SecondsF64) String() string {
-	return d.Duration().String()
-}
-
-func (d SecondsF64) Nanoseconds() int64 {
-	return d.Duration().Nanoseconds()
-}
-
-func (d SecondsF64) Microseconds() int64 {
-	return d.Duration().Microseconds()
-}
-
-func (d SecondsF64) Milliseconds() int64 {
-	return d.Duration().Milliseconds()
-}
-
-func (d SecondsF64) Seconds() float64 {
-	return d.Duration().Seconds()
-}
-
-func (d SecondsF64) Minutes() float64 {
-	return d.Duration().Minutes()
-}
-
-func (d SecondsF64) Hours() float64 {
-	return d.Duration().Hours()
-}
-
-func (d *SecondsF64) UnmarshalJSON(data []byte) error {
-	var secs float64 = 0
-	if err := json.Unmarshal(data, &secs); err != nil {
-		return err
-	}
-	*d = SecondsF64(timeext.FromSeconds(secs))
-	return nil
-}
-
-func (d SecondsF64) MarshalJSON() ([]byte, error) {
-	secs := d.Seconds()
-	return json.Marshal(secs)
-}
-
-func NewSecondsF64(t time.Duration) SecondsF64 {
-	return SecondsF64(t)
-}

rfctime/unix.go

@@ -63,16 +63,16 @@ func (t UnixTime) Serialize() string {
 	return strconv.FormatInt(t.Time().Unix(), 10)
 }
 
-func (t UnixTime) After(u AnyTime) bool {
-	return t.Time().After(tt(u))
+func (t UnixTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
 }
 
-func (t UnixTime) Before(u AnyTime) bool {
-	return t.Time().Before(tt(u))
+func (t UnixTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
 }
 
-func (t UnixTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(tt(u))
+func (t UnixTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
 }
 
 func (t UnixTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixTime) Add(d time.Duration) UnixTime {
 	return UnixTime(t.Time().Add(d))
 }
 
-func (t UnixTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(tt(u))
+func (t UnixTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
 }
 
 func (t UnixTime) AddDate(years int, months int, days int) UnixTime {
@@ -167,10 +167,6 @@ func (t UnixTime) String() string {
 	return t.Time().String()
 }
 
-func (t UnixTime) Location() *time.Location {
-	return t.Time().Location()
-}
-
 func NewUnix(t time.Time) UnixTime {
 	return UnixTime(t)
 }

rfctime/unixMilli.go

@@ -63,16 +63,16 @@ func (t UnixMilliTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixMilli(), 10)
 }
 
-func (t UnixMilliTime) After(u AnyTime) bool {
-	return t.Time().After(tt(u))
+func (t UnixMilliTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
 }
 
-func (t UnixMilliTime) Before(u AnyTime) bool {
-	return t.Time().Before(tt(u))
+func (t UnixMilliTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
 }
 
-func (t UnixMilliTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(tt(u))
+func (t UnixMilliTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
 }
 
 func (t UnixMilliTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixMilliTime) Add(d time.Duration) UnixMilliTime {
 	return UnixMilliTime(t.Time().Add(d))
 }
 
-func (t UnixMilliTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(tt(u))
+func (t UnixMilliTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
 }
 
 func (t UnixMilliTime) AddDate(years int, months int, days int) UnixMilliTime {
@@ -167,10 +167,6 @@ func (t UnixMilliTime) String() string {
 	return t.Time().String()
 }
 
-func (t UnixMilliTime) Location() *time.Location {
-	return t.Time().Location()
-}
-
 func NewUnixMilli(t time.Time) UnixMilliTime {
 	return UnixMilliTime(t)
 }

rfctime/unixNano.go

@@ -63,16 +63,16 @@ func (t UnixNanoTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixNano(), 10)
 }
 
-func (t UnixNanoTime) After(u AnyTime) bool {
-	return t.Time().After(tt(u))
+func (t UnixNanoTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
 }
 
-func (t UnixNanoTime) Before(u AnyTime) bool {
-	return t.Time().Before(tt(u))
+func (t UnixNanoTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
 }
 
-func (t UnixNanoTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(tt(u))
+func (t UnixNanoTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
 }
 
 func (t UnixNanoTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixNanoTime) Add(d time.Duration) UnixNanoTime {
 	return UnixNanoTime(t.Time().Add(d))
 }
 
-func (t UnixNanoTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(tt(u))
+func (t UnixNanoTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
 }
 
 func (t UnixNanoTime) AddDate(years int, months int, days int) UnixNanoTime {
@@ -167,10 +167,6 @@ func (t UnixNanoTime) String() string {
 	return t.Time().String()
 }
 
-func (t UnixNanoTime) Location() *time.Location {
-	return t.Time().Location()
-}
-
 func NewUnixNano(t time.Time) UnixNanoTime {
 	return UnixNanoTime(t)
 }