vendor/github.com/tendermint/go-wire/wire.go

   1 package wire
   2
   3 import (
   4         "encoding/json"
   5         "errors"
   6         "io"
   7         "reflect"
   8
   9         cmn "github.com/tendermint/tmlibs/common"
  10 )
  11
  12 var (
  13         ErrBinaryReadOverflow                  = errors.New("Error: binary read overflow")
  14         ErrBinaryReadInvalidLength             = errors.New("Error: binary read invalid length")
  15         ErrBinaryReadInvalidTimeNegative       = errors.New("Error: binary read invalid time - negative")
  16         ErrBinaryReadInvalidTimeSubMillisecond = errors.New("Error: binary read invalid time - sub millisecond")
  17         ErrBinaryWriteOverflow                 = errors.New("Error: binary write overflow")
  18 )
  19
  20 const (
  21         ReadSliceChunkSize = 1024
  22 )
  23
  24 func ReadBinary(o interface{}, r io.Reader, lmt int, n *int, err *error) (res interface{}) {
  25         rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
  26         if rv.Kind() == reflect.Ptr {
  27                 if rv.IsNil() {
  28                         // This allows ReadBinary() to return a nil pointer,
  29                         // if the value read is nil.
  30                         rvPtr := reflect.New(rt)
  31                         ReadBinaryPtr(rvPtr.Interface(), r, lmt, n, err)
  32                         res = rvPtr.Elem().Interface()
  33                 } else {
  34                         readReflectBinary(rv, rt, Options{}, r, lmt, n, err)
  35                         res = o
  36                 }
  37         } else {
  38                 ptrRv := reflect.New(rt)
  39                 readReflectBinary(ptrRv.Elem(), rt, Options{}, r, lmt, n, err)
  40                 res = ptrRv.Elem().Interface()
  41         }
  42         if lmt != 0 && lmt < *n && *err == nil {
  43                 *err = ErrBinaryReadOverflow
  44         }
  45         return res
  46 }
  47
  48 func ReadBinaryPtr(o interface{}, r io.Reader, lmt int, n *int, err *error) (res interface{}) {
  49         rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
  50         if rv.Kind() == reflect.Ptr {
  51                 readReflectBinary(rv.Elem(), rt.Elem(), Options{}, r, lmt, n, err)
  52         } else {
  53                 cmn.PanicSanity("ReadBinaryPtr expects o to be a pointer")
  54         }
  55         res = o
  56         if lmt != 0 && lmt < *n && *err == nil {
  57                 *err = ErrBinaryReadOverflow
  58         }
  59         return res
  60 }
  61
  62 // WriteBinary is the binary encoder. Its arguments are the subject to be
  63 // encoded, the writer that'll receive the encoded bytes, as well as a
  64 // receiver to store the bytes written and any error encountered.
  65 func WriteBinary(o interface{}, w io.Writer, n *int, err *error) {
  66         rv := reflect.ValueOf(o)
  67         rt := reflect.TypeOf(o)
  68         writeReflectBinary(rv, rt, Options{}, w, n, err)
  69 }
  70
  71 func ReadJSON(o interface{}, bytes []byte, err *error) interface{} {
  72         var object interface{}
  73         *err = json.Unmarshal(bytes, &object)
  74         if *err != nil {
  75                 return o
  76         }
  77
  78         return ReadJSONObject(o, object, err)
  79 }
  80
  81 func ReadJSONPtr(o interface{}, bytes []byte, err *error) interface{} {
  82         var object interface{}
  83         *err = json.Unmarshal(bytes, &object)
  84         if *err != nil {
  85                 return o
  86         }
  87
  88         return ReadJSONObjectPtr(o, object, err)
  89 }
  90
  91 // o is the ultimate destination, object is the result of json unmarshal
  92 func ReadJSONObject(o interface{}, object interface{}, err *error) interface{} {
  93         rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
  94         if rv.Kind() == reflect.Ptr {
  95                 if rv.IsNil() {
  96                         // This allows ReadJSONObject() to return a nil pointer
  97                         // if the value read is nil.
  98                         rvPtr := reflect.New(rt)
  99                         ReadJSONObjectPtr(rvPtr.Interface(), object, err)
 100                         return rvPtr.Elem().Interface()
 101                 } else {
 102                         readReflectJSON(rv, rt, Options{}, object, err)
 103                         return o
 104                 }
 105         } else {
 106                 ptrRv := reflect.New(rt)
 107                 readReflectJSON(ptrRv.Elem(), rt, Options{}, object, err)
 108                 return ptrRv.Elem().Interface()
 109         }
 110 }
 111
 112 func ReadJSONObjectPtr(o interface{}, object interface{}, err *error) interface{} {
 113         rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
 114         if rv.Kind() == reflect.Ptr {
 115                 readReflectJSON(rv.Elem(), rt.Elem(), Options{}, object, err)
 116         } else {
 117                 cmn.PanicSanity("ReadJSON(Object)Ptr expects o to be a pointer")
 118         }
 119         return o
 120 }
 121
 122 func WriteJSON(o interface{}, w io.Writer, n *int, err *error) {
 123         rv := reflect.ValueOf(o)
 124         rt := reflect.TypeOf(o)
 125         if rv.Kind() == reflect.Ptr {
 126                 rv, rt = rv.Elem(), rt.Elem()
 127         }
 128         writeReflectJSON(rv, rt, Options{}, w, n, err)
 129 }
 130
 131 // Write all of bz to w
 132 // Increment n and set err accordingly.
 133 func WriteTo(bz []byte, w io.Writer, n *int, err *error) {
 134         if *err != nil {
 135                 return
 136         }
 137         n_, err_ := w.Write(bz)
 138         *n += n_
 139         *err = err_
 140 }
 141
 142 // Read len(buf) from r
 143 // Increment n and set err accordingly.
 144 func ReadFull(buf []byte, r io.Reader, n *int, err *error) {
 145         if *err != nil {
 146                 return
 147         }
 148         n_, err_ := io.ReadFull(r, buf)
 149         *n += n_
 150         *err = err_
 151 }