github.com/bingoohuang/gg@v0.0.0-20240325092523-45da7dee9335/pkg/reflector/util.go (about)

     1  package reflector
     2  
     3  import "reflect"
     4  
     5  // IsEmpty returns if the object is considered as empty or not.
     6  func IsEmpty(v interface{}) bool {
     7  	var value reflect.Value
     8  	if vv, ok := v.(reflect.Value); ok {
     9  		value = vv
    10  		v = value.Interface()
    11  	} else {
    12  		value = reflect.ValueOf(v)
    13  	}
    14  
    15  	switch value.Kind() {
    16  	case reflect.String:
    17  		return value.Len() == 0
    18  	case reflect.Bool:
    19  		return !value.Bool()
    20  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    21  		return value.Int() == 0
    22  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
    23  		return value.Uint() == 0
    24  	case reflect.Float32, reflect.Float64:
    25  		return value.Float() == 0
    26  	case reflect.Interface, reflect.Ptr:
    27  		return value.IsNil()
    28  	}
    29  
    30  	zero := reflect.Zero(value.Type()).Interface()
    31  	return reflect.DeepEqual(v, zero)
    32  }
    33  
    34  // Indirect returns the value that v points to.
    35  // If v is a nil pointer, Indirect returns a zero Value.
    36  // If v is not a pointer, Indirect returns v.
    37  func Indirect(v reflect.Value) reflect.Value {
    38  	for v.Kind() == reflect.Ptr {
    39  		if ve := v.Elem(); ve.IsValid() {
    40  			v = ve
    41  		}
    42  	}
    43  	return v
    44  }
    45  
    46  // ImplType tells src whether it implements target type.
    47  func ImplType(src, target reflect.Type) bool {
    48  	if src == target {
    49  		return true
    50  	}
    51  
    52  	if src.Kind() == reflect.Ptr {
    53  		return src.Implements(target)
    54  	}
    55  
    56  	if target.Kind() != reflect.Interface {
    57  		return false
    58  	}
    59  
    60  	return reflect.PtrTo(src).Implements(target)
    61  }
    62  
    63  // IsError tells t whether it is error type exactly.
    64  func IsError(t reflect.Type) bool { return t == ErrType }
    65  
    66  // AsError tells t whether it implements error type exactly.
    67  func AsError(t reflect.Type) bool { return ImplType(t, ErrType) }
    68  
    69  // V returns the variadic arguments to slice.
    70  func V(v ...interface{}) []interface{} {
    71  	return v
    72  }
    73  
    74  // V0 returns the one of variadic arguments at index 0.
    75  func V0(v ...interface{}) interface{} {
    76  	return v[0]
    77  }