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

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