util.go

package zinc

import (
	"errors"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
)

func fromPtr[T any](p *T) T {
	if p == nil {
		var empty T
		return empty
	} else {
		return *p
	}
}

func deref(t reflect.Type) reflect.Type {
	if t.Kind() == reflect.Ptr {
		return t.Elem()
	}
	return t
}

func derefDeep(t reflect.Type) reflect.Type {
	for t.Kind() == reflect.Ptr {
		return derefDeep(t.Elem())
	}
	return t
}

func ensureValueDeep(v reflect.Value) reflect.Value {
	for v.Kind() == reflect.Ptr {
		if v.IsNil() {
			v.Set(reflect.New(v.Type().Elem()))
		}
		return ensureValueDeep(v.Elem())
	}
	return v
}

func cloneSlice[T any](slice []T) []T {
	if slice == nil {
		return nil
	}
	r := make([]T, len(slice))
	copy(r, slice)
	return r
}

func ref[T any](v T) *T {
	return &v
}

func refWithErr[T any](v T, err error) (*T, error) {
	if err != nil {
		return nil, err
	}
	return &v, nil

}

func isAny(t reflect.Type) bool {
	return t == typAny
}

func isAnyPtr(t reflect.Type) bool {
	if t.Kind() != reflect.Ptr {
		return false
	}
	return isAny(t.Elem())
}

func isPrimitive(t reflect.Type) bool {
	switch t.Kind() {
	case reflect.String:
		return true
	case reflect.Bool:
		return true
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return true
	case reflect.Float32, reflect.Float64:
		return true
	default:
		if t == typBytes || t == typRawBytes {
			return true
		} else {
			return false
		}
	}
}

func isPrimitivePtr(t reflect.Type) (reflect.Type, bool) {
	if t.Kind() != reflect.Ptr {
		return nil, false
	}
	et := t.Elem()
	if !isPrimitive(et) {
		return nil, false
	}
	return et, true
}

func isRowMap(t reflect.Type) bool {
	if t.Kind() != reflect.Map {
		return false
	}
	if t.Key() != typString {
		return false
	}
	return true
}

func isRowMapPtr(t reflect.Type) (reflect.Type, bool) {
	if t.Kind() != reflect.Ptr {
		return nil, false
	}
	et := t.Elem()
	if !isRowMap(et) {
		return nil, false
	}
	return et, true
}

func isSlice(t reflect.Type) bool {
	return t.Kind() == reflect.Slice
}

func isSliceOrArray(t reflect.Type) bool {
	return t.Kind() == reflect.Slice || t.Kind() == reflect.Array
}

func isSlicePtr(t reflect.Type) (reflect.Type, bool) {
	if t.Kind() != reflect.Ptr {
		return nil, false
	}
	et := t.Elem()
	if !isSlice(et) {
		return nil, false
	}
	return et, true
}

func isStruct(t reflect.Type) bool {
	return t.Kind() == reflect.Struct
}

func isStructPtr(t reflect.Type) (reflect.Type, bool) {
	if t.Kind() != reflect.Ptr {
		return nil, false
	}
	et := t.Elem()
	if !isStruct(et) {
		return nil, false
	}
	return et, true
}

func isStructPtrPtr(t reflect.Type) (reflect.Type, bool) {
	if t.Kind() != reflect.Ptr {
		return nil, false
	}
	return isStructPtr(t.Elem())
}

func getInsAndOuts(funcTyp reflect.Type) ([]reflect.Type, []reflect.Type) {
	numIn := funcTyp.NumIn()
	numOut := funcTyp.NumOut()
	ins := make([]reflect.Type, numIn)
	outs := make([]reflect.Type, numOut)
	for i := 0; i < numIn; i++ {
		ins[i] = funcTyp.In(i)
	}
	for i := 0; i < numOut; i++ {
		outs[i] = funcTyp.Out(i)
	}
	return ins, outs
}

func sliceContains[T comparable](slice []T, target T) bool {
	for _, v := range slice {
		if v == target {
			return true
		}
	}
	return false
}

func b2s(b []byte, charset string) (string, bool) {
	// TODO: charset
	return string(b), true
}

func s2i[T int | int64 | int32 | int16 | int8 | uint | uint64 | uint32 | uint16 | uint8](s string) (T, error) {
	i64, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return 0, err
	}
	return T(i64), nil
}

func s2f[T float32 | float64](s string) (T, error) {
	f64, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return 0, err
	}
	return T(f64), nil

}

func lockR(m *sync.RWMutex, f func()) {
	m.RLock()
	defer m.RUnlock()
	f()
}

func lockW(m *sync.RWMutex, f func()) {
	m.Lock()
	defer m.Unlock()
	f()
}

func splitNonEmpty(s string, sep string) []string {
	if s == "" {
		return nil
	}
	var r []string
	for _, e := range strings.Split(s, sep) {
		e = strings.TrimSpace(e)
		if e != "" {
			r = append(r, e)
		}
	}
	return r
}

func sliceMap[T any, R any](s []T, f func(item T) R) []R {
	if s == nil {
		return nil
	}
	r := make([]R, len(s))
	for i, item := range s {
		r[i] = f(item)
	}
	return r
}

func safeDo(action func()) (err error) {
	if action == nil {
		err = nil
		return
	}

	defer func() {
		if err0 := recover(); err0 != nil {
			switch err1 := err0.(type) {
			case nil:
				err = nil
			case error:
				err = err1
			case string:
				err = errors.New(err1)
			default:
				err = fmt.Errorf("%v", err1)
			}
		}
	}()
	action()
	return
}

func str2bool(s string) bool {
	s = strings.ToLower(s)
	return s == "true" || s == "1" || s == "yes"
}

func valueOf(v any) reflect.Value {
	if v == nil {
		return reflect.ValueOf(nil)
	}
	if v1, ok := v.(reflect.Value); ok {
		return v1
	}
	return reflect.ValueOf(v)
}

func typeOf(v any) reflect.Type {
	if v == nil {
		return nil
	}
	if v1, ok := v.(reflect.Type); ok {
		return v1
	}
	return reflect.TypeOf(v)
}