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

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