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

   1 package wire
   2
   3 import (
   4         "encoding/binary"
   5         "errors"
   6         "io"
   7 )
   8
   9 // Byte
  10
  11 func WriteByte(b byte, w io.Writer, n *int, err *error) {
  12         WriteTo([]byte{b}, w, n, err)
  13 }
  14
  15 func ReadByte(r io.Reader, n *int, err *error) byte {
  16         var buf [1]byte
  17         ReadFull(buf[:], r, n, err)
  18         return buf[0]
  19 }
  20
  21 // Int8
  22
  23 func WriteInt8(i int8, w io.Writer, n *int, err *error) {
  24         WriteByte(byte(i), w, n, err)
  25 }
  26
  27 func ReadInt8(r io.Reader, n *int, err *error) int8 {
  28         return int8(ReadByte(r, n, err))
  29 }
  30
  31 // Uint8
  32
  33 func WriteUint8(i uint8, w io.Writer, n *int, err *error) {
  34         WriteByte(byte(i), w, n, err)
  35 }
  36
  37 func ReadUint8(r io.Reader, n *int, err *error) uint8 {
  38         return uint8(ReadByte(r, n, err))
  39 }
  40
  41 // Int16
  42
  43 func WriteInt16(i int16, w io.Writer, n *int, err *error) {
  44         var buf [2]byte
  45         binary.BigEndian.PutUint16(buf[:], uint16(i))
  46         *n += 2
  47         WriteTo(buf[:], w, n, err)
  48 }
  49
  50 func ReadInt16(r io.Reader, n *int, err *error) int16 {
  51         var buf [2]byte
  52         ReadFull(buf[:], r, n, err)
  53         return int16(binary.BigEndian.Uint16(buf[:]))
  54 }
  55
  56 func PutInt16(buf []byte, i int16) {
  57         binary.BigEndian.PutUint16(buf, uint16(i))
  58 }
  59
  60 func GetInt16(buf []byte) int16 {
  61         return int16(binary.BigEndian.Uint16(buf))
  62 }
  63
  64 // Uint16
  65
  66 func WriteUint16(i uint16, w io.Writer, n *int, err *error) {
  67         var buf [2]byte
  68         binary.BigEndian.PutUint16(buf[:], uint16(i))
  69         *n += 2
  70         WriteTo(buf[:], w, n, err)
  71 }
  72
  73 func ReadUint16(r io.Reader, n *int, err *error) uint16 {
  74         var buf [2]byte
  75         ReadFull(buf[:], r, n, err)
  76         return uint16(binary.BigEndian.Uint16(buf[:]))
  77 }
  78
  79 func PutUint16(buf []byte, i uint16) {
  80         binary.BigEndian.PutUint16(buf, i)
  81 }
  82
  83 func GetUint16(buf []byte) uint16 {
  84         return binary.BigEndian.Uint16(buf)
  85 }
  86
  87 // Int32
  88
  89 func WriteInt32(i int32, w io.Writer, n *int, err *error) {
  90         var buf [4]byte
  91         binary.BigEndian.PutUint32(buf[:], uint32(i))
  92         *n += 4
  93         WriteTo(buf[:], w, n, err)
  94 }
  95
  96 func ReadInt32(r io.Reader, n *int, err *error) int32 {
  97         var buf [4]byte
  98         ReadFull(buf[:], r, n, err)
  99         return int32(binary.BigEndian.Uint32(buf[:]))
 100 }
 101
 102 func PutInt32(buf []byte, i int32) {
 103         binary.BigEndian.PutUint32(buf, uint32(i))
 104 }
 105
 106 func GetInt32(buf []byte) int32 {
 107         return int32(binary.BigEndian.Uint32(buf))
 108 }
 109
 110 // Uint32
 111
 112 func WriteUint32(i uint32, w io.Writer, n *int, err *error) {
 113         var buf [4]byte
 114         binary.BigEndian.PutUint32(buf[:], uint32(i))
 115         *n += 4
 116         WriteTo(buf[:], w, n, err)
 117 }
 118
 119 func ReadUint32(r io.Reader, n *int, err *error) uint32 {
 120         var buf [4]byte
 121         ReadFull(buf[:], r, n, err)
 122         return uint32(binary.BigEndian.Uint32(buf[:]))
 123 }
 124
 125 func PutUint32(buf []byte, i uint32) {
 126         binary.BigEndian.PutUint32(buf, i)
 127 }
 128
 129 func GetUint32(buf []byte) uint32 {
 130         return binary.BigEndian.Uint32(buf)
 131 }
 132
 133 // Int64
 134
 135 func WriteInt64(i int64, w io.Writer, n *int, err *error) {
 136         var buf [8]byte
 137         binary.BigEndian.PutUint64(buf[:], uint64(i))
 138         *n += 8
 139         WriteTo(buf[:], w, n, err)
 140 }
 141
 142 func ReadInt64(r io.Reader, n *int, err *error) int64 {
 143         var buf [8]byte
 144         ReadFull(buf[:], r, n, err)
 145         return int64(binary.BigEndian.Uint64(buf[:]))
 146 }
 147
 148 func PutInt64(buf []byte, i int64) {
 149         binary.BigEndian.PutUint64(buf, uint64(i))
 150 }
 151
 152 func GetInt64(buf []byte) int64 {
 153         return int64(binary.BigEndian.Uint64(buf))
 154 }
 155
 156 // Uint64
 157
 158 func WriteUint64(i uint64, w io.Writer, n *int, err *error) {
 159         var buf [8]byte
 160         binary.BigEndian.PutUint64(buf[:], uint64(i))
 161         *n += 8
 162         WriteTo(buf[:], w, n, err)
 163 }
 164
 165 func ReadUint64(r io.Reader, n *int, err *error) uint64 {
 166         var buf [8]byte
 167         ReadFull(buf[:], r, n, err)
 168         return uint64(binary.BigEndian.Uint64(buf[:]))
 169 }
 170
 171 func PutUint64(buf []byte, i uint64) {
 172         binary.BigEndian.PutUint64(buf, i)
 173 }
 174
 175 func GetUint64(buf []byte) uint64 {
 176         return binary.BigEndian.Uint64(buf)
 177 }
 178
 179 func uvarintSize(i uint64) int {
 180         if i == 0 {
 181                 return 0
 182         }
 183         if i < 1<<8 {
 184                 return 1
 185         }
 186         if i < 1<<16 {
 187                 return 2
 188         }
 189         if i < 1<<24 {
 190                 return 3
 191         }
 192         if i < 1<<32 {
 193                 return 4
 194         }
 195         if i < 1<<40 {
 196                 return 5
 197         }
 198         if i < 1<<48 {
 199                 return 6
 200         }
 201         if i < 1<<56 {
 202                 return 7
 203         }
 204         return 8
 205 }
 206
 207 func WriteVarint(i int, w io.Writer, n *int, err *error) {
 208         var negate = false
 209         if i < 0 {
 210                 negate = true
 211                 i = -i
 212         }
 213         var size = uvarintSize(uint64(i))
 214         if negate {
 215                 // e.g. 0xF1 for a single negative byte
 216                 WriteUint8(uint8(size+0xF0), w, n, err)
 217         } else {
 218                 WriteUint8(uint8(size), w, n, err)
 219         }
 220         if size > 0 {
 221                 var buf [8]byte
 222                 binary.BigEndian.PutUint64(buf[:], uint64(i))
 223                 WriteTo(buf[(8-size):], w, n, err)
 224         }
 225 }
 226
 227 func ReadVarint(r io.Reader, n *int, err *error) int {
 228         var size = ReadUint8(r, n, err)
 229         var negate = false
 230         if (size >> 4) == 0xF {
 231                 negate = true
 232                 size = size & 0x0F
 233         }
 234         if size > 8 {
 235                 setFirstErr(err, errors.New("Varint overflow"))
 236                 return 0
 237         }
 238         if size == 0 {
 239                 if negate {
 240                         setFirstErr(err, errors.New("Varint does not allow negative zero"))
 241                 }
 242                 return 0
 243         }
 244         var buf [8]byte
 245         ReadFull(buf[(8-size):], r, n, err)
 246         var i = int(binary.BigEndian.Uint64(buf[:]))
 247         if negate {
 248                 return -i
 249         } else {
 250                 return i
 251         }
 252 }
 253
 254 func PutVarint(buf []byte, i int) (n int, err error) {
 255         var negate = false
 256         if i < 0 {
 257                 negate = true
 258                 i = -i
 259         }
 260         var size = uvarintSize(uint64(i))
 261         if len(buf) < size+1 {
 262                 return 0, errors.New("Insufficient buffer length")
 263         }
 264         if negate {
 265                 // e.g. 0xF1 for a single negative byte
 266                 buf[0] = byte(size + 0xF0)
 267         } else {
 268                 buf[0] = byte(size)
 269         }
 270         if size > 0 {
 271                 var buf2 [8]byte
 272                 binary.BigEndian.PutUint64(buf2[:], uint64(i))
 273                 copy(buf[1:], buf2[(8-size):])
 274         }
 275         return size + 1, nil
 276 }
 277
 278 func GetVarint(buf []byte) (i int, n int, err error) {
 279         if len(buf) == 0 {
 280                 return 0, 0, errors.New("Insufficent buffer length")
 281         }
 282         var size = int(buf[0])
 283         var negate = false
 284         if (size >> 4) == 0xF {
 285                 negate = true
 286                 size = size & 0x0F
 287         }
 288         if size > 8 {
 289                 return 0, 0, errors.New("Varint overflow")
 290         }
 291         if size == 0 {
 292                 if negate {
 293                         return 0, 0, errors.New("Varint does not allow negative zero")
 294                 }
 295                 return 0, 1, nil
 296         }
 297         if len(buf) < 1+size {
 298                 return 0, 0, errors.New("Insufficient buffer length")
 299         }
 300         var buf2 [8]byte
 301         copy(buf2[(8-size):], buf[1:1+size])
 302         i = int(binary.BigEndian.Uint64(buf2[:]))
 303         if negate {
 304                 return -i, size + 1, nil
 305         } else {
 306                 return i, size + 1, nil
 307         }
 308 }
 309
 310 // Uvarint
 311
 312 func WriteUvarint(i uint, w io.Writer, n *int, err *error) {
 313         var size = uvarintSize(uint64(i))
 314         WriteUint8(uint8(size), w, n, err)
 315         if size > 0 {
 316                 var buf [8]byte
 317                 binary.BigEndian.PutUint64(buf[:], uint64(i))
 318                 WriteTo(buf[(8-size):], w, n, err)
 319         }
 320 }
 321
 322 func ReadUvarint(r io.Reader, n *int, err *error) uint {
 323         var size = ReadUint8(r, n, err)
 324         if size > 8 {
 325                 setFirstErr(err, errors.New("Uvarint overflow"))
 326                 return 0
 327         }
 328         if size == 0 {
 329                 return 0
 330         }
 331         var buf [8]byte
 332         ReadFull(buf[(8-size):], r, n, err)
 333         return uint(binary.BigEndian.Uint64(buf[:]))
 334 }
 335
 336 func PutUvarint(buf []byte, i uint) (n int, err error) {
 337         var size = uvarintSize(uint64(i))
 338         if len(buf) < size+1 {
 339                 return 0, errors.New("Insufficient buffer length")
 340         }
 341         buf[0] = byte(size)
 342         if size > 0 {
 343                 var buf2 [8]byte
 344                 binary.BigEndian.PutUint64(buf2[:], uint64(i))
 345                 copy(buf[1:], buf2[(8-size):])
 346         }
 347         return size + 1, nil
 348 }
 349
 350 func GetUvarint(buf []byte) (i uint, n int, err error) {
 351         if len(buf) == 0 {
 352                 return 0, 0, errors.New("Insufficent buffer length")
 353         }
 354         var size = int(buf[0])
 355         if size > 8 {
 356                 return 0, 0, errors.New("Uvarint overflow")
 357         }
 358         if size == 0 {
 359                 return 0, 1, nil
 360         }
 361         if len(buf) < 1+size {
 362                 return 0, 0, errors.New("Insufficient buffer length")
 363         }
 364         var buf2 [8]byte
 365         copy(buf2[(8-size):], buf[1:1+size])
 366         i = uint(binary.BigEndian.Uint64(buf2[:]))
 367         return i, size + 1, nil
 368 }
 369
 370 func setFirstErr(err *error, newErr error) {
 371         if *err == nil && newErr != nil {
 372                 *err = newErr
 373         }
 374 }