You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

628 lines
13 KiB

package xstring
import (
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"github.com/pkg/errors"
"reflect"
"regexp"
"sort"
"strconv"
"strings"
"unicode"
)
func TableFieldNames(obj any) ([]string, string) {
v := reflect.TypeOf(obj)
cols := []string{}
primary := ""
for i := 0; i < v.NumField(); i++ {
cols = append(cols, v.Field(i).Tag.Get("db"))
if primary == "" {
primary = v.Field(i).Tag.Get("primaryKey")
}
}
return cols, primary
}
func Remove[T string](cols []T, key T) []T {
arr := make([]T, 0)
for _, v := range cols {
if key != v {
arr = append(arr, v)
}
}
return arr
}
func NamedSql(cls []string) string {
str := []string{}
for _, v := range cls {
str = append(str, fmt.Sprintf("%s=:%s", v, v))
}
return strings.Join(str, ",")
}
func StripTags(content string) string {
re := regexp.MustCompile(`<(.|\n)*?>`)
return re.ReplaceAllString(content, "")
}
func SubString(str string, begin, length int) string {
rs := []rune(str)
lth := len(rs)
if begin < 0 {
begin = 0
}
if begin >= lth {
begin = lth
}
end := begin + length
if end > lth {
end = lth
}
return string(rs[begin:end])
}
func Nl2br(str string) string {
return strings.Join(strings.Split(strings.Join(strings.Split(str, "\r"), "<br/>"), "\n"), "<br/>")
}
func Serialize(value interface{}) ([]byte, error) {
if value == nil {
return MarshalNil(), nil
}
t := reflect.TypeOf(value)
switch t.Kind() {
case reflect.Bool:
return MarshalBool(value.(bool)), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
return MarshalNumber(value), nil
case reflect.String:
return MarshalString(value.(string)), nil
case reflect.Map:
return MarshalMap(value)
case reflect.Slice:
return MarshalSlice(value)
default:
return nil, fmt.Errorf("Marshal: Unknown type %T with value %#v", t, value)
}
}
func MarshalNil() []byte {
return []byte("N;")
}
func MarshalBool(value bool) []byte {
if value {
return []byte("b:1;")
}
return []byte("b:0;")
}
func MarshalNumber(value interface{}) []byte {
var val string
isFloat := false
switch value.(type) {
default:
val = "0"
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
val, _ = NumericalToString(value)
case float32, float64:
val, _ = NumericalToString(value)
isFloat = true
}
if isFloat {
return []byte("d:" + val + ";")
} else {
return []byte("i:" + val + ";")
}
}
func NumericalValue(value reflect.Value) (float64, bool) {
switch value.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return float64(value.Int()), true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return float64(value.Uint()), true
case reflect.Float32, reflect.Float64:
return value.Float(), true
default:
return 0, false
}
}
func MarshalString(value string) []byte {
return []byte(fmt.Sprintf("s:%d:\"%s\";", len(value), value))
}
func LessValue(a, b reflect.Value) bool {
aValue, aNumerical := NumericalValue(a)
bValue, bNumerical := NumericalValue(b)
if aNumerical && bNumerical {
return aValue < bValue
}
if !aNumerical && !bNumerical {
// In theory this should mean they are both strings. In reality
// they could be any other type and the String() representation
// will be something like "<bool>" if it is not a string. Since
// distinct values of non-strings still return the same value
// here that's what makes the ordering undefined.
return strings.Compare(a.String(), b.String()) < 0
}
// Numerical values are always treated as less than other types
// (including strings that might represent numbers themselves). The
// inverse is also true.
return aNumerical && !bNumerical
}
func MarshalMap(value interface{}) ([]byte, error) {
s := reflect.ValueOf(value)
mapKeys := s.MapKeys()
sort.Slice(mapKeys, func(i, j int) bool {
return LessValue(mapKeys[i], mapKeys[j])
})
var buffer bytes.Buffer
for _, mapKey := range mapKeys {
m, err := Serialize(mapKey.Interface())
if err != nil {
return nil, err
}
buffer.Write(m)
m, err = Serialize(s.MapIndex(mapKey).Interface())
if err != nil {
return nil, err
}
buffer.Write(m)
}
return []byte(fmt.Sprintf("a:%d:{%s}", s.Len(), buffer.String())), nil
}
func MarshalSlice(value interface{}) ([]byte, error) {
s := reflect.ValueOf(value)
var buffer bytes.Buffer
for i := 0; i < s.Len(); i++ {
m, err := Serialize(i)
if err != nil {
return nil, err
}
buffer.Write(m)
m, err = Serialize(s.Index(i).Interface())
if err != nil {
return nil, err
}
buffer.Write(m)
}
return []byte(fmt.Sprintf("a:%d:{%s}", s.Len(), buffer.String())), nil
}
const UNSERIALIZABLE_OBJECT_MAX_LEN = int64(10 * 1024 * 1024 * 1024)
func UnSerialize(data []byte) (interface{}, error) {
reader := bytes.NewReader(data)
return unMarshalByReader(reader)
}
func UnSerializeBind(data []byte, post any) error {
reader := bytes.NewReader(data)
b, err := unMarshalByReader(reader)
if err != nil {
return err
}
bb, err := json.Marshal(b)
if err != nil {
return err
}
return json.Unmarshal(bb, post)
}
func unMarshalByReader(reader *bytes.Reader) (interface{}, error) {
for {
if token, _, err := reader.ReadRune(); err == nil {
switch token {
default:
return nil, fmt.Errorf("UnMarshal: Unknown token %#U", token)
case 'N':
return unMarshalNil(reader)
case 'b':
return unMarshalBool(reader)
case 'i':
return unMarshalNumber(reader, false)
case 'd':
return unMarshalNumber(reader, true)
case 's':
return unMarshalString(reader, true)
case 'a':
return unMarshalArray(reader)
// case 'O':
// case 'C':
// case 'R', 'r':
// case 'x':
}
}
}
}
func unMarshalNil(reader *bytes.Reader) (interface{}, error) {
_ = expect(reader, ';')
return nil, nil
}
func unMarshalBool(reader *bytes.Reader) (interface{}, error) {
var (
raw rune
err error
)
err = expect(reader, ':')
if err != nil {
return nil, err
}
if raw, _, err = reader.ReadRune(); err != nil {
return nil, fmt.Errorf("UnMarshal: Error while reading bool value: %v", err)
}
err = expect(reader, ';')
if err != nil {
return nil, err
}
return raw == '1', nil
}
func unMarshalNumber(reader *bytes.Reader, isFloat bool) (interface{}, error) {
var (
raw string
err error
val interface{}
)
err = expect(reader, ':')
if err != nil {
return nil, err
}
if raw, err = readUntil(reader, ';'); err != nil {
return nil, fmt.Errorf("UnMarshal: Error while reading number value: %v", err)
} else {
if isFloat {
if val, err = strconv.ParseFloat(raw, 64); err != nil {
return nil, fmt.Errorf("UnMarshal: Unable to convert %s to float: %v", raw, err)
}
} else {
if val, err = strconv.Atoi(raw); err != nil {
return nil, fmt.Errorf("UnMarshal: Unable to convert %s to int: %v", raw, err)
}
}
}
return val, nil
}
func unMarshalString(reader *bytes.Reader, isFinal bool) (interface{}, error) {
var (
err error
val interface{}
strLen int
readLen int
)
strLen, err = readLength(reader)
if err != nil {
return nil, err
}
err = expect(reader, '"')
if err != nil {
return nil, err
}
if strLen > 0 {
buf := make([]byte, strLen)
if readLen, err = reader.Read(buf); err != nil {
return nil, fmt.Errorf("UnMarshal: Error while reading string value: %v", err)
} else {
if readLen != strLen {
return nil, fmt.Errorf("UnMarshal: Unable to read string. Expected %d but have got %d bytes", strLen, readLen)
} else {
val = string(buf)
}
}
}
err = expect(reader, '"')
if err != nil {
return nil, err
}
if isFinal {
err = expect(reader, ';')
if err != nil {
return nil, err
}
}
return val, nil
}
func unMarshalArray(reader *bytes.Reader) (interface{}, error) {
var arrLen int
var err error
val := make(map[string]interface{})
arrLen, err = readLength(reader)
if err != nil {
return nil, err
}
err = expect(reader, '{')
if err != nil {
return nil, err
}
indexLen := 0
for i := 0; i < arrLen; i++ {
k, err := unMarshalByReader(reader)
if err != nil {
return nil, err
}
v, err := unMarshalByReader(reader)
if err != nil {
return nil, err
}
// if errKey == nil && errVal == nil {
// val[k] = v
switch t := k.(type) {
default:
return nil, fmt.Errorf("UnMarshal: Unexpected key type %T", t)
case string:
stringKey, _ := k.(string)
val[stringKey] = v
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
// intKey, _ := k.(int)
// val[strconv.Itoa(intKey)] = v
stringKey, _ := NumericalToString(k)
val[stringKey] = v
// stringI, _ := utils.NumericalToString(i)
if i == k {
indexLen++
}
}
// } else {
// return nil, fmt.Errorf("UnMarshal: Error while reading key or(and) value of array")
// }
}
err = expect(reader, '}')
if err != nil {
return nil, err
}
if indexLen == arrLen {
var slice []interface{}
for _, row := range val {
slice = append(slice, row)
}
return slice, nil
}
return val, nil
}
func expect(reader *bytes.Reader, expected rune) error {
if token, _, err := reader.ReadRune(); err != nil {
return fmt.Errorf("UnMarshal: Error while reading expected rune %#U: %v", expected, err)
} else if token != expected {
return fmt.Errorf("UnMarshal: Expected %#U but have got %#U", expected, token)
}
return nil
}
func readUntil(reader *bytes.Reader, stop rune) (string, error) {
var (
token rune
err error
)
buf := bytes.NewBuffer([]byte{})
for {
if token, _, err = reader.ReadRune(); err != nil || token == stop {
break
} else {
buf.WriteRune(token)
}
}
return buf.String(), err
}
func readLength(reader *bytes.Reader) (int, error) {
var (
raw string
err error
val int
)
err = expect(reader, ':')
if err != nil {
return 0, err
}
if raw, err = readUntil(reader, ':'); err != nil {
return 0, fmt.Errorf("UnMarshal: Error while reading lenght of value: %v", err)
} else {
if val, err = strconv.Atoi(raw); err != nil {
return 0, fmt.Errorf("UnMarshal: Unable to convert %s to int: %v", raw, err)
} else if int64(val) > UNSERIALIZABLE_OBJECT_MAX_LEN {
return 0, fmt.Errorf("UnMarshal: Unserializable object length looks too big(%d). If you are sure you wanna unserialise it, please increase UNSERIALIZABLE_OBJECT_MAX_LEN const", val)
}
}
return val, nil
}
func NumericalToString(value interface{}) (string, bool) {
var val string
switch intVal := value.(type) {
default:
return "0", false
case int:
val = strconv.FormatInt(int64(intVal), 10)
case int8:
val = strconv.FormatInt(int64(intVal), 10)
case int16:
val = strconv.FormatInt(int64(intVal), 10)
case int32:
val = strconv.FormatInt(int64(intVal), 10)
case int64:
val = strconv.FormatInt(int64(intVal), 10)
case uint:
val = strconv.FormatUint(uint64(intVal), 10)
case uint8:
val = strconv.FormatUint(uint64(intVal), 10)
case uint16:
val = strconv.FormatUint(uint64(intVal), 10)
case uint32:
val = strconv.FormatUint(uint64(intVal), 10)
case uint64:
val = strconv.FormatUint(intVal, 10)
case float32:
val = strconv.FormatFloat(float64(intVal), 'f', -1, 32)
case float64:
val = strconv.FormatFloat(intVal, 'f', -1, 64)
}
return val, true
}
//func StrToArr(str string) []string {
// re := regexp.MustCompile(`<(.|\n)*?>`)
// str = re.ReplaceAllString(str, " ")
// str = strings.ReplaceAll(str, `"`, "")
// str = strings.ReplaceAll(str, `'`, "")
// str = strings.ReplaceAll(str, "`", "")
// str = strings.ReplaceAll(str, ",", "")
// str = strings.ReplaceAll(str, "&nbsp;", "")
// newStr := []string{}
// tmp := ""
// for i := 0; i < len(str); {
// r, n := utf8.DecodeRuneInString(str[i:])
// if n == 3 {
// tmp = ""
// newStr = append(newStr, string(r))
// } else {
//
// if string(r) == " " {
// newStr = append(newStr, tmp)
// tmp = ""
// } else if string(r) != "\n" {
// tmp = fmt.Sprintf("%s%c", tmp, r)
// }
// }
// i += n
// }
// if tmp != "" {
// newStr = append(newStr, tmp)
// tmp = ""
// }
// newStr1 := make([]string, 0)
// for _, v := range newStr {
// if strings.TrimSpace(v) == "" {
// continue
// }
// newStr1 = append(newStr1, strings.TrimSpace(v))
// }
// return newStr1
//}
//func StrToUrl(str string) string {
// strs := []string{}
// for _, v := range StrToArr(str) {
// fmt.Println(v)
// }
//
// return strings.Join(strs, "-")
//}
func Base64Encode(s string) string {
return base64.StdEncoding.EncodeToString([]byte(s))
}
func Base64Decode(s string) (string, error) {
b, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", errors.Wrap(err, "")
}
return string(b), nil
}
func Ucfirst(str string) string {
for i, v := range str {
return string(unicode.ToUpper(v)) + str[i+1:]
}
return ""
}
func Lcfirst(str string) string {
for i, v := range str {
return string(unicode.ToLower(v)) + str[i+1:]
}
return ""
}
func GetUrlRequestURI(url string) string {
urls := strings.Split(url, "?")
urls = strings.Split(urls[0], " ")
if len(urls) > 1 {
return urls[1]
}
return ""
}
func CoverInt64(str string) int64 {
i, _ := strconv.ParseInt(str, 10, 64)
return i
}
func ToInterfaceSlice(slice interface{}) []interface{} {
s := reflect.ValueOf(slice)
if s.Kind() != reflect.Slice {
panic("InterfaceSlice() given a non-slice type")
}
ret := make([]interface{}, s.Len())
for i := 0; i < s.Len(); i++ {
ret[i] = s.Index(i).Interface()
}
return ret
}