From b1fc83ab93bf8e020a0a37b136dd378df6270dc1 Mon Sep 17 00:00:00 2001
From: Stanly <eashingliaw@gmail.com>
Date: Thu, 11 Jan 2024 15:43:45 +0800
Subject: [PATCH] Add slice (int, uint, int8, uint8, int16, uint16, int64,
 uint64, float64)

---
 types/data.go | 550 ++++++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 463 insertions(+), 87 deletions(-)

diff --git a/types/data.go b/types/data.go
index ee873f4..b18195d 100644
--- a/types/data.go
+++ b/types/data.go
@@ -24,73 +24,50 @@ func (data Data) Get(key string) (interface{}, error) {
 	return value, nil
 }
 
-// GetString 取得字串
-func (data Data) GetString(key string) (string, error) {
-	value, err := data.Get(key)
-	if err != nil {
-		return "", err
-	}
-
-	switch value := value.(type) {
-	case []byte:
-		return string(value), nil
-	case string:
-		return value, nil
-	default:
-		return "", ErrFormat
-	}
-}
-
-// MustGetString 強制取得字串
-func (data Data) MustGetString(key string) string {
-	value, _ := data.GetString(key)
-	return value
-}
-
-// GetBytes 取得字串
-func (data Data) GetBytes(key string) ([]byte, error) {
+// GetSlice 取得切片
+func (data Data) GetSlice(key string) (res Slice, err error) {
 	value, err := data.Get(key)
 	if err != nil {
 		return nil, err
 	}
 
 	switch value := value.(type) {
-	case []byte:
+	case []interface{}:
+		return value, nil
+	case Slice:
 		return value, nil
-	case string:
-		return []byte(value), nil
 	default:
 		return nil, ErrFormat
 	}
 }
 
-// MustGetBytes 強制取得字串
-func (data Data) MustGetBytes(key string) []byte {
-	value, _ := data.GetBytes(key)
-	return value
+// MustGetSlice 強制取得切片
+func (data Data) MustGetSlice(key string) Slice {
+	values, _ := data.GetSlice(key)
+	return values
 }
 
-// GetSlice 取得切片
-func (data Data) GetSlice(key string) (res Slice, err error) {
+// GetString 取得字串
+func (data Data) GetString(key string) (string, error) {
 	value, err := data.Get(key)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 
 	switch value := value.(type) {
-	case []interface{}:
-		return Slice(value), nil
-	case Slice:
+	case []byte:
+		return string(value), nil
+	case string:
 		return value, nil
 	default:
-		return nil, ErrFormat
+		return "", ErrFormat
 	}
 }
 
-// MustGetSlice 強制取得切片
-func (data Data) MustGetSlice(key string) Slice {
-	values, _ := data.GetSlice(key)
-	return values
+// MustGetString 強制取得字串
+func (data Data) MustGetString(key string) string {
+	value, _ := data.GetString(key)
+	return value
 }
 
 // GetStringSlice 取得字串切片
@@ -118,51 +95,27 @@ func (data Data) MustGetStringSlice(key string) []string {
 	return values
 }
 
-// GetIntSlice 取得整數切片
-func (data Data) GetIntSlice(key string) (res []int, err error) {
-	values, err := data.GetSlice(key)
+// GetBytes 取得字串
+func (data Data) GetBytes(key string) ([]byte, error) {
+	value, err := data.Get(key)
 	if err != nil {
 		return nil, err
 	}
 
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, int(v))
-		case uint:
-			res = append(res, int(v))
-		case int8:
-			res = append(res, int(v))
-		case uint8:
-			res = append(res, int(v))
-		case int16:
-			res = append(res, int(v))
-		case uint16:
-			res = append(res, int(v))
-		case int32:
-			res = append(res, int(v))
-		case uint32:
-			res = append(res, int(v))
-		case int64:
-			res = append(res, int(v))
-		case uint64:
-			res = append(res, int(v))
-		case float32:
-			res = append(res, int(v))
-		case float64:
-			res = append(res, int(v))
-		default:
-			return nil, ErrFormat
-		}
+	switch value := value.(type) {
+	case []byte:
+		return value, nil
+	case string:
+		return []byte(value), nil
+	default:
+		return nil, ErrFormat
 	}
-
-	return res, nil
 }
 
-// MustGetIntSlice 強制取得整數切片
-func (data Data) MustGetIntSlice(key string) []int {
-	values, _ := data.GetIntSlice(key)
-	return values
+// MustGetBytes 強制取得字串
+func (data Data) MustGetBytes(key string) []byte {
+	value, _ := data.GetBytes(key)
+	return value
 }
 
 // GetData 取得資料
@@ -195,17 +148,17 @@ func (data Data) GetDataSlice(key string) ([]Data, error) {
 		return nil, err
 	}
 
-	var vals []Data
+	var list []Data
 	for _, v := range values {
 		switch v := v.(type) {
-		case map[string]interface{}:
-			vals = append(vals, Data(v))
+		case Data:
+			list = append(list, v)
 		default:
 			return nil, ErrFormat
 		}
 	}
 
-	return vals, nil
+	return list, nil
 }
 
 // MustGetDataSlice 強制取得資料切片
@@ -237,6 +190,53 @@ func (data Data) MustGetFloat64(key string) float64 {
 	return value
 }
 
+// GetFloat64Slice 取得64位元浮點數切片
+func (data Data) GetFloat64Slice(key string) (res []float64, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, float64(v))
+		case uint:
+			res = append(res, float64(v))
+		case int8:
+			res = append(res, float64(v))
+		case uint8:
+			res = append(res, float64(v))
+		case int16:
+			res = append(res, float64(v))
+		case uint16:
+			res = append(res, float64(v))
+		case int32:
+			res = append(res, float64(v))
+		case uint32:
+			res = append(res, float64(v))
+		case int64:
+			res = append(res, float64(v))
+		case uint64:
+			res = append(res, float64(v))
+		case float32:
+			res = append(res, float64(v))
+		case float64:
+			res = append(res, v)
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetFloat64Slice 強制取得64位元浮點數切片
+func (data Data) MustGetFloat64Slice(key string) []float64 {
+	values, _ := data.GetFloat64Slice(key)
+	return values
+}
+
 // GetInt64 取得64位元整數
 func (data Data) GetInt64(key string) (int64, error) {
 	value, err := data.Get(key)
@@ -276,6 +276,53 @@ func (data Data) MustGetInt64(key string) int64 {
 	return value
 }
 
+// GetInt64Slice 取得64位元整數切片
+func (data Data) GetInt64Slice(key string) (res []int64, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, int64(v))
+		case uint:
+			res = append(res, int64(v))
+		case int8:
+			res = append(res, int64(v))
+		case uint8:
+			res = append(res, int64(v))
+		case int16:
+			res = append(res, int64(v))
+		case uint16:
+			res = append(res, int64(v))
+		case int32:
+			res = append(res, int64(v))
+		case uint32:
+			res = append(res, int64(v))
+		case int64:
+			res = append(res, v)
+		case uint64:
+			res = append(res, int64(v))
+		case float32:
+			res = append(res, int64(v))
+		case float64:
+			res = append(res, int64(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetInt64Slice 強制取得64位元整數切片
+func (data Data) MustGetInt64Slice(key string) []int64 {
+	values, _ := data.GetInt64Slice(key)
+	return values
+}
+
 // GetUint64 取得64位元正整數
 func (data Data) GetUint64(key string) (uint64, error) {
 	value, err := data.GetInt64(key)
@@ -296,6 +343,53 @@ func (data Data) MustGetUint64(key string) uint64 {
 	return value
 }
 
+// GetUint64Slice 取得64位元正整數切片
+func (data Data) GetUint64Slice(key string) (res []uint64, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, uint64(v))
+		case uint:
+			res = append(res, uint64(v))
+		case int8:
+			res = append(res, uint64(v))
+		case uint8:
+			res = append(res, uint64(v))
+		case int16:
+			res = append(res, uint64(v))
+		case uint16:
+			res = append(res, uint64(v))
+		case int32:
+			res = append(res, uint64(v))
+		case uint32:
+			res = append(res, uint64(v))
+		case int64:
+			res = append(res, uint64(v))
+		case uint64:
+			res = append(res, v)
+		case float32:
+			res = append(res, uint64(v))
+		case float64:
+			res = append(res, uint64(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetUint64Slice 強制取得64位元正整數切片
+func (data Data) MustGetUint64Slice(key string) []uint64 {
+	values, _ := data.GetUint64Slice(key)
+	return values
+}
+
 // GetInt 取得整數
 func (data Data) GetInt(key string) (int, error) {
 	value, err := data.GetInt64(key)
@@ -312,6 +406,53 @@ func (data Data) MustGetInt(key string) int {
 	return value
 }
 
+// GetIntSlice 取得整數切片
+func (data Data) GetIntSlice(key string) (res []int, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, v)
+		case uint:
+			res = append(res, int(v))
+		case int8:
+			res = append(res, int(v))
+		case uint8:
+			res = append(res, int(v))
+		case int16:
+			res = append(res, int(v))
+		case uint16:
+			res = append(res, int(v))
+		case int32:
+			res = append(res, int(v))
+		case uint32:
+			res = append(res, int(v))
+		case int64:
+			res = append(res, int(v))
+		case uint64:
+			res = append(res, int(v))
+		case float32:
+			res = append(res, int(v))
+		case float64:
+			res = append(res, int(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetIntSlice 強制取得整數切片
+func (data Data) MustGetIntSlice(key string) []int {
+	values, _ := data.GetIntSlice(key)
+	return values
+}
+
 // GetUint 取得正整數
 func (data Data) GetUint(key string) (uint, error) {
 	value, err := data.GetInt64(key)
@@ -332,6 +473,53 @@ func (data Data) MustGetUint(key string) uint {
 	return value
 }
 
+// GetUintSlice 取得正整數切片
+func (data Data) GetUintSlice(key string) (res []uint, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, uint(v))
+		case uint:
+			res = append(res, v)
+		case int8:
+			res = append(res, uint(v))
+		case uint8:
+			res = append(res, uint(v))
+		case int16:
+			res = append(res, uint(v))
+		case uint16:
+			res = append(res, uint(v))
+		case int32:
+			res = append(res, uint(v))
+		case uint32:
+			res = append(res, uint(v))
+		case int64:
+			res = append(res, uint(v))
+		case uint64:
+			res = append(res, uint(v))
+		case float32:
+			res = append(res, uint(v))
+		case float64:
+			res = append(res, uint(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetUintSlice 強制取得正整數切片
+func (data Data) MustGetUintSlice(key string) []uint {
+	values, _ := data.GetUintSlice(key)
+	return values
+}
+
 // GetInt16 取得16位元整數
 func (data Data) GetInt16(key string) (int16, error) {
 	value, err := data.GetInt64(key)
@@ -348,6 +536,53 @@ func (data Data) MustGetInt16(key string) uint16 {
 	return value
 }
 
+// GetInt16Slice 取得16位元整數切片
+func (data Data) GetInt16Slice(key string) (res []int16, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, int16(v))
+		case uint:
+			res = append(res, int16(v))
+		case int8:
+			res = append(res, int16(v))
+		case uint8:
+			res = append(res, int16(v))
+		case int16:
+			res = append(res, v)
+		case uint16:
+			res = append(res, int16(v))
+		case int32:
+			res = append(res, int16(v))
+		case uint32:
+			res = append(res, int16(v))
+		case int64:
+			res = append(res, int16(v))
+		case uint64:
+			res = append(res, int16(v))
+		case float32:
+			res = append(res, int16(v))
+		case float64:
+			res = append(res, int16(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetInt16Slice 強制取得16位元整數切片
+func (data Data) MustGetInt16Slice(key string) []int16 {
+	values, _ := data.GetInt16Slice(key)
+	return values
+}
+
 // GetUint16 取得16位元正整數
 func (data Data) GetUint16(key string) (uint16, error) {
 	value, err := data.GetInt64(key)
@@ -368,6 +603,53 @@ func (data Data) MustGetUint16(key string) uint16 {
 	return value
 }
 
+// GetUint16Slice 取得16位元正整數切片
+func (data Data) GetUint16Slice(key string) (res []uint16, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, uint16(v))
+		case uint:
+			res = append(res, uint16(v))
+		case int8:
+			res = append(res, uint16(v))
+		case uint8:
+			res = append(res, uint16(v))
+		case int16:
+			res = append(res, uint16(v))
+		case uint16:
+			res = append(res, v)
+		case int32:
+			res = append(res, uint16(v))
+		case uint32:
+			res = append(res, uint16(v))
+		case int64:
+			res = append(res, uint16(v))
+		case uint64:
+			res = append(res, uint16(v))
+		case float32:
+			res = append(res, uint16(v))
+		case float64:
+			res = append(res, uint16(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetUint16Slice 強制取得16位元正整數切片
+func (data Data) MustGetUint16Slice(key string) []uint16 {
+	values, _ := data.GetUint16Slice(key)
+	return values
+}
+
 // GetInt8 取得8位元整數
 func (data Data) GetInt8(key string) (int8, error) {
 	value, err := data.GetInt64(key)
@@ -384,6 +666,53 @@ func (data Data) MustGetInt8(key string) int8 {
 	return value
 }
 
+// GetInt8Slice 取得8位元整數切片
+func (data Data) GetInt8Slice(key string) (res []int8, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, int8(v))
+		case uint:
+			res = append(res, int8(v))
+		case int8:
+			res = append(res, v)
+		case uint8:
+			res = append(res, int8(v))
+		case int16:
+			res = append(res, int8(v))
+		case uint16:
+			res = append(res, int8(v))
+		case int32:
+			res = append(res, int8(v))
+		case uint32:
+			res = append(res, int8(v))
+		case int64:
+			res = append(res, int8(v))
+		case uint64:
+			res = append(res, int8(v))
+		case float32:
+			res = append(res, int8(v))
+		case float64:
+			res = append(res, int8(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetInt8Slice 強制取得8位元整數切片
+func (data Data) MustGetInt8Slice(key string) []int8 {
+	values, _ := data.GetInt8Slice(key)
+	return values
+}
+
 // GetUint8 取得8位元正整數
 func (data Data) GetUint8(key string) (uint8, error) {
 	value, err := data.GetInt64(key)
@@ -404,6 +733,53 @@ func (data Data) MustGetUint8(key string) uint8 {
 	return value
 }
 
+// GetUint8Slice 取得8位元正整數切片
+func (data Data) GetUint8Slice(key string) (res []uint8, err error) {
+	values, err := data.GetSlice(key)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, uint8(v))
+		case uint:
+			res = append(res, uint8(v))
+		case int8:
+			res = append(res, uint8(v))
+		case uint8:
+			res = append(res, v)
+		case int16:
+			res = append(res, uint8(v))
+		case uint16:
+			res = append(res, uint8(v))
+		case int32:
+			res = append(res, uint8(v))
+		case uint32:
+			res = append(res, uint8(v))
+		case int64:
+			res = append(res, uint8(v))
+		case uint64:
+			res = append(res, uint8(v))
+		case float32:
+			res = append(res, uint8(v))
+		case float64:
+			res = append(res, uint8(v))
+		default:
+			return nil, ErrFormat
+		}
+	}
+
+	return res, nil
+}
+
+// MustGetUint8Slice 強制取得8位元正整數切片
+func (data Data) MustGetUint8Slice(key string) []uint8 {
+	values, _ := data.GetUint8Slice(key)
+	return values
+}
+
 // GetBool 取得布林值
 func (data Data) GetBool(key string) (bool, error) {
 	value, err := data.Get(key)
@@ -479,7 +855,7 @@ func (data Data) MustJSON() []byte {
 	return bs
 }
 
-// Get 取得資料
+// GetPage 取得頁數
 func (data Data) GetPage(key string) (*Page, error) {
 	value, err := data.Get(key)
 	if err != nil {
@@ -494,7 +870,7 @@ func (data Data) GetPage(key string) (*Page, error) {
 	return nil, ErrFormat
 }
 
-// Get 取得資料
+// MustGetPage 強制取得頁數
 func (data Data) MustGetPage(key string) *Page {
 	value, _ := data.GetPage(key)