vendor/github.com/hashicorp/go-msgpack/codec/helper_internal.go

   1 // Copyright (c) 2012, 2013 Ugorji Nwoke. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license found in the LICENSE file.
   3
   4 package codec
   5
   6 // All non-std package dependencies live in this file,
   7 // so porting to different environment is easy (just update functions).
   8
   9 import (
  10         "errors"
  11         "fmt"
  12         "math"
  13         "reflect"
  14 )
  15
  16 var (
  17         raisePanicAfterRecover = false
  18         debugging              = true
  19 )
  20
  21 func panicValToErr(panicVal interface{}, err *error) {
  22         switch xerr := panicVal.(type) {
  23         case error:
  24                 *err = xerr
  25         case string:
  26                 *err = errors.New(xerr)
  27         default:
  28                 *err = fmt.Errorf("%v", panicVal)
  29         }
  30         if raisePanicAfterRecover {
  31                 panic(panicVal)
  32         }
  33         return
  34 }
  35
  36 func isEmptyValueDeref(v reflect.Value, deref bool) bool {
  37         switch v.Kind() {
  38         case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
  39                 return v.Len() == 0
  40         case reflect.Bool:
  41                 return !v.Bool()
  42         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  43                 return v.Int() == 0
  44         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  45                 return v.Uint() == 0
  46         case reflect.Float32, reflect.Float64:
  47                 return v.Float() == 0
  48         case reflect.Interface, reflect.Ptr:
  49                 if deref {
  50                         if v.IsNil() {
  51                                 return true
  52                         }
  53                         return isEmptyValueDeref(v.Elem(), deref)
  54                 } else {
  55                         return v.IsNil()
  56                 }
  57         case reflect.Struct:
  58                 // return true if all fields are empty. else return false.
  59
  60                 // we cannot use equality check, because some fields may be maps/slices/etc
  61                 // and consequently the structs are not comparable.
  62                 // return v.Interface() == reflect.Zero(v.Type()).Interface()
  63                 for i, n := 0, v.NumField(); i < n; i++ {
  64                         if !isEmptyValueDeref(v.Field(i), deref) {
  65                                 return false
  66                         }
  67                 }
  68                 return true
  69         }
  70         return false
  71 }
  72
  73 func isEmptyValue(v reflect.Value) bool {
  74         return isEmptyValueDeref(v, true)
  75 }
  76
  77 func debugf(format string, args ...interface{}) {
  78         if debugging {
  79                 if len(format) == 0 || format[len(format)-1] != '\n' {
  80                         format = format + "\n"
  81                 }
  82                 fmt.Printf(format, args...)
  83         }
  84 }
  85
  86 func pruneSignExt(v []byte, pos bool) (n int) {
  87         if len(v) < 2 {
  88         } else if pos && v[0] == 0 {
  89                 for ; v[n] == 0 && n+1 < len(v) && (v[n+1]&(1<<7) == 0); n++ {
  90                 }
  91         } else if !pos && v[0] == 0xff {
  92                 for ; v[n] == 0xff && n+1 < len(v) && (v[n+1]&(1<<7) != 0); n++ {
  93                 }
  94         }
  95         return
  96 }
  97
  98 func implementsIntf(typ, iTyp reflect.Type) (success bool, indir int8) {
  99         if typ == nil {
 100                 return
 101         }
 102         rt := typ
 103         // The type might be a pointer and we need to keep
 104         // dereferencing to the base type until we find an implementation.
 105         for {
 106                 if rt.Implements(iTyp) {
 107                         return true, indir
 108                 }
 109                 if p := rt; p.Kind() == reflect.Ptr {
 110                         indir++
 111                         if indir >= math.MaxInt8 { // insane number of indirections
 112                                 return false, 0
 113                         }
 114                         rt = p.Elem()
 115                         continue
 116                 }
 117                 break
 118         }
 119         // No luck yet, but if this is a base type (non-pointer), the pointer might satisfy.
 120         if typ.Kind() != reflect.Ptr {
 121                 // Not a pointer, but does the pointer work?
 122                 if reflect.PtrTo(typ).Implements(iTyp) {
 123                         return true, -1
 124                 }
 125         }
 126         return false, 0
 127 }