json, reflect added

encoding/json/json.go

@@ -0,0 +1,54 @@
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	our "git.loafle.net/overflow/util-go/reflect"
+)
+
+// SetValueWithJSONStringArray set the value of json string array
+// raw([]byte) is ["1", {"a": 1}, [1, 2]]
+// targets([]interface{}) is array of pointer ex) *int, *string, *[], *map, *struct
+func SetValueWithJSONStringArrayBytes(raw []byte, targets []interface{}) error {
+	var values []string
+	if err := json.Unmarshal(raw, &values); err != nil {
+		return err
+	}
+
+	return SetValueWithJSONStringArray(values, targets)
+}
+
+func SetValueWithJSONStringArray(values []string, targets []interface{}) error {
+	if len(targets) != len(values) {
+		return fmt.Errorf("Count of raw[%d] and targets[%d] is not same", len(values), len(targets))
+	}
+
+	for indexI := 0; indexI < len(values); indexI++ {
+		target := targets[indexI]
+		value := values[indexI]
+
+		if reflect.Ptr != reflect.TypeOf(target).Kind() {
+			return fmt.Errorf("Type of target[%d] must be ptr but is %s, value=%s", indexI, reflect.TypeOf(target).Kind(), value)
+		}
+
+		switch reflect.TypeOf(target).Elem().Kind() {
+		case reflect.Array, reflect.Slice, reflect.Map, reflect.Struct:
+			if err := json.Unmarshal([]byte(value), &target); nil != err {
+				return err
+			}
+		case reflect.Ptr:
+			return fmt.Errorf("Type of target[%d] cannot be double ptr, value=%s", indexI, value)
+		default:
+			cv, err := our.ConvertToType(value, reflect.TypeOf(target).Elem())
+			if nil != err {
+				return fmt.Errorf("Type conversion of value[%s] has been failed to %s[%d]", value, reflect.TypeOf(target).Elem().Kind(), indexI)
+			}
+
+			reflect.ValueOf(target).Elem().Set(reflect.ValueOf(cv))
+		}
+	}
+
+	return nil
+}

encoding/json/number.go

@@ -0,0 +1,14 @@
+package json
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+func NumberToInt(n json.Number) (int, error) {
+	n64, err := strconv.ParseInt(n.String(), 10, 32)
+	if nil != err {
+		return 0, err
+	}
+	return int(n64), nil
+}

reflect/error.go

@@ -0,0 +1,41 @@
+package reflect
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type ErrCanNotConvertType struct {
+	value  interface{}
+	from   reflect.Type
+	to     reflect.Type
+	reason []string
+}
+
+func (e ErrCanNotConvertType) Error() string {
+	var (
+		reason = strings.Join(e.reason, ", ")
+	)
+
+	if reason != "" {
+		reason = ", reason: " + reason
+	}
+
+	return fmt.Sprintf(
+		"Can not convert '%#v' of type '%s' to '%s'%s",
+		e.value,
+		e.from,
+		e.to,
+		reason,
+	)
+}
+
+func NewErrCanNotConvertType(value interface{}, from reflect.Type, to reflect.Type, reason ...string) ErrCanNotConvertType {
+	return ErrCanNotConvertType{
+		value:  value,
+		from:   from,
+		to:     to,
+		reason: reason,
+	}
+}

reflect/indirect.go

@@ -0,0 +1,31 @@
+package reflect
+
+import (
+	"reflect"
+)
+
+func Indirect(v interface{}) interface{} {
+	if v == nil {
+		return nil
+	}
+
+	return IndirectValue(reflect.ValueOf(v)).Interface()
+}
+
+func IndirectValue(reflectValue reflect.Value) reflect.Value {
+	if reflectValue.Kind() == reflect.Ptr {
+		return reflectValue.Elem()
+	}
+	return reflectValue
+}
+
+func IndirectType(reflectType reflect.Type) reflect.Type {
+	if reflectType == TypeInvalid {
+		return TypeInvalid
+	}
+
+	if reflectType.Kind() == reflect.Ptr {
+		return reflectType.Elem()
+	}
+	return reflectType
+}

reflect/kind.go

@@ -0,0 +1,35 @@
+package reflect
+
+import (
+	"reflect"
+)
+
+const (
+	Invalid       = reflect.Invalid
+	Bool          = reflect.Bool
+	Int           = reflect.Int
+	Int8          = reflect.Int8
+	Int16         = reflect.Int16
+	Int32         = reflect.Int32
+	Int64         = reflect.Int64
+	Uint          = reflect.Uint
+	Uint8         = reflect.Uint8
+	Uint16        = reflect.Uint16
+	Uint32        = reflect.Uint32
+	Uint64        = reflect.Uint64
+	Uintptr       = reflect.Uintptr
+	Float32       = reflect.Float32
+	Float64       = reflect.Float64
+	Complex64     = reflect.Complex64
+	Complex128    = reflect.Complex128
+	Array         = reflect.Array
+	Chan          = reflect.Chan
+	Func          = reflect.Func
+	Interface     = reflect.Interface
+	Map           = reflect.Map
+	Ptr           = reflect.Ptr
+	Slice         = reflect.Slice
+	String        = reflect.String
+	Struct        = reflect.Struct
+	UnsafePointer = reflect.UnsafePointer
+)

reflect/type.go

@@ -0,0 +1,72 @@
+package reflect
+
+import (
+	"reflect"
+)
+
+var (
+	TypeOf = reflect.TypeOf
+)
+
+var (
+	Types = []reflect.Type{
+		TypeBool,
+		TypeInt,
+		TypeInt8,
+		TypeInt16,
+		TypeInt32,
+		TypeInt64,
+		TypeUint,
+		TypeUint8,
+		TypeUint16,
+		TypeUint32,
+		TypeUint64,
+		TypeFloat32,
+		TypeFloat64,
+		TypeComplex64,
+		TypeComplex128,
+		TypeUintptr,
+		TypeString,
+	}
+
+	TypeInvalid    = reflect.Type(nil)
+	TypeBool       = reflect.TypeOf(false)
+	TypeInt        = reflect.TypeOf(int(0))
+	TypeInt8       = reflect.TypeOf(int8(0))
+	TypeInt16      = reflect.TypeOf(int16(0))
+	TypeInt32      = reflect.TypeOf(int32(0))
+	TypeInt64      = reflect.TypeOf(int64(0))
+	TypeUint       = reflect.TypeOf(uint(0))
+	TypeUint8      = reflect.TypeOf(uint8(0))
+	TypeUint16     = reflect.TypeOf(uint16(0))
+	TypeUint32     = reflect.TypeOf(uint32(0))
+	TypeUint64     = reflect.TypeOf(uint64(0))
+	TypeFloat32    = reflect.TypeOf(float32(0))
+	TypeFloat64    = reflect.TypeOf(float64(0))
+	TypeComplex64  = reflect.TypeOf(complex64(0))
+	TypeComplex128 = reflect.TypeOf(complex128(0))
+	TypeUintptr    = reflect.TypeOf(uintptr(0))
+	TypeString     = reflect.TypeOf(string(""))
+)
+
+func IsTypeKind(t reflect.Type, kind reflect.Kind, removePtr bool) bool {
+	if reflect.Ptr == t.Kind() {
+		if removePtr {
+			return IsTypeKind(t.Elem(), kind, removePtr)
+		}
+	}
+
+	return kind == t.Kind()
+}
+
+func GetTypeInfo(t reflect.Type) (realType reflect.Type, pkgName string, name string) {
+	if reflect.Ptr == t.Kind() {
+		return GetTypeInfo(t.Elem())
+	}
+
+	return t, t.PkgPath(), t.Name()
+}
+
+func ConvertStringToType() {
+
+}