store - utils.go

     1  package store
     2  
     3  import (
     4  	"reflect"
     5  	"time"
     6  )
     7  
     8  func isPointerStruct(i interface{}) bool {
     9  	t := reflect.TypeOf(i)
    10  	return t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct
    11  }
    12  
    13  func getFieldPointer(i interface{}, fieldNum int) interface{} {
    14  	v := reflect.ValueOf(i).Elem()
    15  	if v.NumField() < fieldNum {
    16  		return nil
    17  	}
    18  	if v.Type().Field(fieldNum).PkgPath != "" {
    19  		return nil
    20  	}
    21  	f := v.Field(fieldNum)
    22  	if f.Kind() == reflect.Ptr {
    23  		return f.Interface()
    24  	}
    25  	return f.Addr().Interface()
    26  }
    27  
    28  func getField(i interface{}, fieldNum int) interface{} {
    29  	v := reflect.ValueOf(i).Elem()
    30  	if v.NumField() < fieldNum {
    31  		return nil
    32  	}
    33  	if v.Type().Field(fieldNum).PkgPath != "" {
    34  		return nil
    35  	}
    36  	f := v.Field(fieldNum)
    37  	if f.Kind() == reflect.Ptr {
    38  		return f.Elem().Interface()
    39  	}
    40  	return f.Interface()
    41  }
    42  
    43  func getType(i interface{}, fieldNum int) string {
    44  	v := getFieldPointer(i, fieldNum)
    45  	if v == nil {
    46  		return ""
    47  	}
    48  	switch v.(type) {
    49  	case *int, *int64, *time.Time:
    50  		return "INTEGER"
    51  	case *float32, *float64:
    52  		return "FLOAT"
    53  	case *string:
    54  		return "TEXT"
    55  	case *[]byte:
    56  		return "BLOB"
    57  	}
    58  	return ""
    59  }
    60  
    61  func isValidType(i interface{}) bool {
    62  	switch i.(type) {
    63  	case *int, *int64,
    64  		*string, *float32, *float64, *bool, *time.Time:
    65  		return true
    66  	}
    67  	return false
    68  }
    69  
    70  func isValidKeyType(i interface{}) bool {
    71  	switch i.(type) {
    72  	case *int, *int64:
    73  		return true
    74  	}
    75  	return false
    76  }
    77  
    78  func typeName(i interface{}) string {
    79  	name := reflect.TypeOf(i).String()
    80  	if name[0] == '*' {
    81  		name = name[1:]
    82  	}
    83  	return name
    84  }
    85  
    86  func (t *typeInfo) GetID(i interface{}) int64 {
    87  	if !isPointerStruct(i) {
    88  		return 0
    89  	}
    90  	switch v := getField(i, t.fields[t.primary].pos).(type) {
    91  	case int:
    92  		return int64(v)
    93  	case int64:
    94  		return v
    95  	}
    96  	return 0
    97  }
    98  
    99  func (t *typeInfo) SetID(i interface{}, id int64) {
   100  	if !isPointerStruct(i) {
   101  		return
   102  	}
   103  	switch v := getFieldPointer(i, t.fields[t.primary].pos).(type) {
   104  	case *int:
   105  		*v = int(id)
   106  	case *int64:
   107  		*v = id
   108  	}
   109  }