feat: pointer

tools/pointer/bool.go

@@ -0,0 +1,28 @@
+package pointer
+
+// ToBoolPointer 将布尔变量转换为布尔指针
+func ToBoolPointer(boolValue bool) *bool {
+	return &boolValue
+}
+
+// ToBoolPointerOrNilIfFalse 将布尔变量转换为布尔类型的指针，如果变量的值为false的话则转换为nil指针
+func ToBoolPointerOrNilIfFalse(boolValue bool) *bool {
+	if boolValue {
+		return &boolValue
+	}
+	return nil
+}
+
+// FromBoolPointer 获取布尔指针实际指向的值，如果指针为nil的话则返回false
+func FromBoolPointer(boolPointer *bool) bool {
+	return FromBoolPointerOrDefault(boolPointer, false)
+}
+
+// FromBoolPointerOrDefault 获取布尔指针实际指向的值，如果指针为nil的话则返回defaultValue
+func FromBoolPointerOrDefault(boolPointer *bool, defaultValue bool) bool {
+	if boolPointer == nil {
+		return defaultValue
+	} else {
+		return *boolPointer
+	}
+}

tools/pointer/string.go

@@ -0,0 +1,27 @@
+package pointer
+
+// ToStringPointer 将string类型的变量转换为对应的*string指针类型
+func ToStringPointer(v string) *string {
+	return &v
+}
+
+// ToStringPointerOrNilIfEmpty 将string类型的变量转换为对应的*string指针类型，如果变量的值为空字符串的话则返回nil指针
+func ToStringPointerOrNilIfEmpty(v string) *string {
+	if v == "" {
+		return nil
+	}
+	return &v
+}
+
+// FromStringPointer 获取*string类型的指针的实际值，如果指针为nil的话则返回空字符串
+func FromStringPointer(p *string) string {
+	return FromStringPointerOrDefaultIfNil(p, "")
+}
+
+// FromStringPointerOrDefaultIfNil 获取*string类型的指针的实际值，如果指针为nil的话则返回defaultValue
+func FromStringPointerOrDefaultIfNil(v *string, defaultValue string) string {
+	if v == nil {
+		return defaultValue
+	}
+	return *v
+}

tools/pointer/template.txt

@@ -0,0 +1,27 @@
+package pointer
+
+// To{{upper}}Pointer 将{{lower}}类型的变量转换为对应的*{{lower}}指针类型
+func To{{upper}}Pointer(v {{lower}}) *{{lower}} {
+	return &v
+}
+
+// To{{upper}}PointerOrNilIfZero 将{{lower}}类型的变量转换为对应的*{{lower}}指针类型，如果变量的值为0的话则返回nil指针
+func To{{upper}}PointerOrNilIfZero(v {{lower}}) *{{lower}} {
+	if v == 0 {
+		return nil
+	}
+	return &v
+}
+
+// From{{upper}}Pointer 获取*{{lower}}类型的指针的实际值，如果指针为nil的话则返回0
+func From{{upper}}Pointer(p *{{lower}}) {{lower}} {
+	return From{{upper}}PointerOrDefaultIfNil(p, 0)
+}
+
+// From{{upper}}PointerOrDefaultIfNil 获取*{{lower}}类型的指针的实际值，如果指针为nil的话则返回defaultValue
+func From{{upper}}PointerOrDefaultIfNil(v *{{lower}}, defaultValue {{lower}}) {{lower}} {
+	if v == nil {
+		return defaultValue
+	}
+	return *v
+}

tools/pointer/time_duration.go

@@ -0,0 +1,29 @@
+package pointer
+
+import "time"
+
+// ToDurationPointer 将time.Duration类型的变量转换为对应的*time.Duration指针类型
+func ToDurationPointer(v time.Duration) *time.Duration {
+	return &v
+}
+
+// ToDurationPointerOrNilIfZero 将time.Duration类型的变量转换为对应的*time.Duration指针类型，如果变量的值为0的话则返回nil指针
+func ToDurationPointerOrNilIfZero(v time.Duration) *time.Duration {
+	if v == 0 {
+		return nil
+	}
+	return &v
+}
+
+// FromDurationPointer 获取*time.Duration类型的指针的实际值，如果指针为nil的话则返回0
+func FromDurationPointer(p *time.Duration) time.Duration {
+	return FromDurationPointerOrDefaultIfNil(p, 0)
+}
+
+// FromDurationPointerOrDefaultIfNil 获取*time.Duration类型的指针的实际值，如果指针为nil的话则返回defaultValue
+func FromDurationPointerOrDefaultIfNil(v *time.Duration, defaultValue time.Duration) time.Duration {
+	if v == nil {
+		return defaultValue
+	}
+	return *v
+}

tools/pointer/time_time.go

@@ -0,0 +1,30 @@
+package pointer
+
+import "time"
+
+// NowTimePointer 返回当前时间的指针表示形式 *time.Time
+func NowTimePointer() *time.Time {
+	f := time.Now()
+	return &f
+}
+
+// ToTimePointer 将time.Time类型转换为指针，如果时间为零值则返回空指针
+func ToTimePointer(t time.Time) *time.Time {
+	if t.IsZero() {
+		return nil
+	}
+	return &t
+}
+
+// FromTimePointer 从time.Time类型的指针中读取时间，如果为空指针，则读取到零值
+func FromTimePointer(t *time.Time) time.Time {
+	return FromTimePointerOrDefault(t, time.Time{})
+}
+
+// FromTimePointerOrDefault 从time.Time类型的指针中读取时间，如果为空指针，则返回defaultValue
+func FromTimePointerOrDefault(t *time.Time, defaultValue time.Time) time.Time {
+	if t == nil {
+		return defaultValue
+	}
+	return *t
+}

tools/pointer/type_gen.go

@@ -0,0 +1,52 @@
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"bytes"
+	"go/format"
+	"io/ioutil"
+	"os"
+	"strings"
+)
+
+var packageName = "package pointer"
+
+func main() {
+	f, err := os.Open("template.txt")
+	if err != nil {
+		panic(err)
+	}
+	fileData, err := ioutil.ReadAll(f)
+	if err != nil {
+		panic(err)
+	}
+
+	w := new(bytes.Buffer)
+	start_pos := strings.Index(string(fileData), packageName)
+	w.WriteString(string(fileData)[start_pos : start_pos+len(packageName)])
+
+	ts := []string{"Byte", "Complex64", "Complex128", "Float32", "Float64", "Int", "Int8", "Int16", "Int32", "Int64", "Rune", "Uint", "Uint8", "Uint16", "Uint32", "Uint64", "Uintptr"}
+
+	for _, upper := range ts {
+		lower := strings.ToLower(upper)
+		data := string(fileData)
+
+		data = data[start_pos+len(packageName):]
+
+		data = strings.Replace(data, "{{upper}}", upper, -1)
+		data = strings.Replace(data, "{{lower}}", lower, -1)
+
+		w.WriteString(data)
+		w.WriteString("\r\n")
+	}
+
+	out, err := format.Source(w.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	if err := ioutil.WriteFile("types.go", out, 0660); err != nil {
+		panic(err)
+	}
+}