From dbda182b10d443e06d62f5ed50bec32a71fe8a56 Mon Sep 17 00:00:00 2001
From: tiglog <me@tiglog.com>
Date: Wed, 21 Jun 2023 10:47:04 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=20Scan=20=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0=EF=BC=8C=E8=83=BD=E6=8A=8A=E5=AD=97=E8=8A=82=E6=95=B0?=
 =?UTF-8?q?=E6=8D=AE=E8=BD=AC=E6=8D=A2=E4=B8=BA=E5=9F=BA=E6=9C=AC=E7=9A=84?=
 =?UTF-8?q?=E6=95=B0=E6=8D=AE=E7=B1=BB=E5=9E=8B=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 helper/conv_helper.go      |  22 +++++++
 helper/scan_helper.go      | 124 +++++++++++++++++++++++++++++++++++++
 helper/scan_helper_test.go |  23 +++++++
 3 files changed, 169 insertions(+)
 create mode 100644 helper/scan_helper.go
 create mode 100644 helper/scan_helper_test.go

diff --git a/helper/conv_helper.go b/helper/conv_helper.go
index 4b01a44..b4de183 100644
--- a/helper/conv_helper.go
+++ b/helper/conv_helper.go
@@ -9,6 +9,7 @@ package helper
 
 import (
 	"strconv"
+	"unsafe"
 )
 
 func AnyToInt(val any, dv int) (int, error) {
@@ -115,3 +116,24 @@ func AnyToString(val any, dv string) (string, error) {
 
 	return dv, nil
 }
+
+// BytesToString converts byte slice to string.
+func BytesToString(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+func Atoi(b []byte) (int, error) {
+	return strconv.Atoi(BytesToString(b))
+}
+
+func ParseInt(b []byte, base int, bitSize int) (int64, error) {
+	return strconv.ParseInt(BytesToString(b), base, bitSize)
+}
+
+func ParseUint(b []byte, base int, bitSize int) (uint64, error) {
+	return strconv.ParseUint(BytesToString(b), base, bitSize)
+}
+
+func ParseFloat(b []byte, bitSize int) (float64, error) {
+	return strconv.ParseFloat(BytesToString(b), bitSize)
+}
diff --git a/helper/scan_helper.go b/helper/scan_helper.go
new file mode 100644
index 0000000..c5a9500
--- /dev/null
+++ b/helper/scan_helper.go
@@ -0,0 +1,124 @@
+//
+// scan_helper.go
+// Copyright (C) 2023 tiglog <me@tiglog.com>
+//
+// Distributed under terms of the MIT license.
+//
+
+package helper
+
+import (
+	"encoding"
+	"fmt"
+	"time"
+)
+
+func Scan(b []byte, v interface{}) error {
+	switch v := v.(type) {
+	case nil:
+		return fmt.Errorf("golib helper: Scan(nil)")
+	case *string:
+		*v = BytesToString(b)
+		return nil
+	case *[]byte:
+		*v = b
+		return nil
+	case *int:
+		var err error
+		*v, err = Atoi(b)
+		return err
+	case *int8:
+		n, err := ParseInt(b, 10, 8)
+		if err != nil {
+			return err
+		}
+		*v = int8(n)
+		return nil
+	case *int16:
+		n, err := ParseInt(b, 10, 16)
+		if err != nil {
+			return err
+		}
+		*v = int16(n)
+		return nil
+	case *int32:
+		n, err := ParseInt(b, 10, 32)
+		if err != nil {
+			return err
+		}
+		*v = int32(n)
+		return nil
+	case *int64:
+		n, err := ParseInt(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = n
+		return nil
+	case *uint:
+		n, err := ParseUint(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = uint(n)
+		return nil
+	case *uint8:
+		n, err := ParseUint(b, 10, 8)
+		if err != nil {
+			return err
+		}
+		*v = uint8(n)
+		return nil
+	case *uint16:
+		n, err := ParseUint(b, 10, 16)
+		if err != nil {
+			return err
+		}
+		*v = uint16(n)
+		return nil
+	case *uint32:
+		n, err := ParseUint(b, 10, 32)
+		if err != nil {
+			return err
+		}
+		*v = uint32(n)
+		return nil
+	case *uint64:
+		n, err := ParseUint(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = n
+		return nil
+	case *float32:
+		n, err := ParseFloat(b, 32)
+		if err != nil {
+			return err
+		}
+		*v = float32(n)
+		return err
+	case *float64:
+		var err error
+		*v, err = ParseFloat(b, 64)
+		return err
+	case *bool:
+		*v = len(b) == 1 && b[0] == '1'
+		return nil
+	case *time.Time:
+		var err error
+		*v, err = time.Parse(time.RFC3339Nano, BytesToString(b))
+		return err
+	case *time.Duration:
+		n, err := ParseInt(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = time.Duration(n)
+		return nil
+	case encoding.BinaryUnmarshaler:
+		return v.UnmarshalBinary(b)
+	default:
+		return fmt.Errorf(
+			"golib: can't unmarshal %T (consider implementing BinaryUnmarshaler)", v)
+	}
+}
diff --git a/helper/scan_helper_test.go b/helper/scan_helper_test.go
new file mode 100644
index 0000000..fb813b4
--- /dev/null
+++ b/helper/scan_helper_test.go
@@ -0,0 +1,23 @@
+//
+// scan_helper_test.go
+// Copyright (C) 2023 tiglog <me@tiglog.com>
+//
+// Distributed under terms of the MIT license.
+//
+
+package helper_test
+
+import (
+	"fmt"
+	"testing"
+
+	"git.hexq.cn/tiglog/golib/helper"
+)
+
+func TestScan(t *testing.T) {
+	var foo = []byte("hello")
+	var dest string
+	helper.Scan(foo, &dest)
+	fmt.Println(dest)
+
+}