go/encode.go

   1 package flatbuffers
   2
   3 import (
   4         "math"
   5 )
   6
   7 type (
   8         // A SOffsetT stores a signed offset into arbitrary data.
   9         SOffsetT int32
  10         // A UOffsetT stores an unsigned offset into vector data.
  11         UOffsetT uint32
  12         // A VOffsetT stores an unsigned offset in a vtable.
  13         VOffsetT uint16
  14 )
  15
  16 const (
  17         // VtableMetadataFields is the count of metadata fields in each vtable.
  18         VtableMetadataFields = 2
  19 )
  20
  21 // GetByte decodes a little-endian byte from a byte slice.
  22 func GetByte(buf []byte) byte {
  23         return byte(GetUint8(buf))
  24 }
  25
  26 // GetBool decodes a little-endian bool from a byte slice.
  27 func GetBool(buf []byte) bool {
  28         return buf[0] == 1
  29 }
  30
  31 // GetUint8 decodes a little-endian uint8 from a byte slice.
  32 func GetUint8(buf []byte) (n uint8) {
  33         n = uint8(buf[0])
  34         return
  35 }
  36
  37 // GetUint16 decodes a little-endian uint16 from a byte slice.
  38 func GetUint16(buf []byte) (n uint16) {
  39         _ = buf[1] // Force one bounds check. See: golang.org/issue/14808
  40         n |= uint16(buf[0])
  41         n |= uint16(buf[1]) << 8
  42         return
  43 }
  44
  45 // GetUint32 decodes a little-endian uint32 from a byte slice.
  46 func GetUint32(buf []byte) (n uint32) {
  47         _ = buf[3] // Force one bounds check. See: golang.org/issue/14808
  48         n |= uint32(buf[0])
  49         n |= uint32(buf[1]) << 8
  50         n |= uint32(buf[2]) << 16
  51         n |= uint32(buf[3]) << 24
  52         return
  53 }
  54
  55 // GetUint64 decodes a little-endian uint64 from a byte slice.
  56 func GetUint64(buf []byte) (n uint64) {
  57         _ = buf[7] // Force one bounds check. See: golang.org/issue/14808
  58         n |= uint64(buf[0])
  59         n |= uint64(buf[1]) << 8
  60         n |= uint64(buf[2]) << 16
  61         n |= uint64(buf[3]) << 24
  62         n |= uint64(buf[4]) << 32
  63         n |= uint64(buf[5]) << 40
  64         n |= uint64(buf[6]) << 48
  65         n |= uint64(buf[7]) << 56
  66         return
  67 }
  68
  69 // GetInt8 decodes a little-endian int8 from a byte slice.
  70 func GetInt8(buf []byte) (n int8) {
  71         n = int8(buf[0])
  72         return
  73 }
  74
  75 // GetInt16 decodes a little-endian int16 from a byte slice.
  76 func GetInt16(buf []byte) (n int16) {
  77         _ = buf[1] // Force one bounds check. See: golang.org/issue/14808
  78         n |= int16(buf[0])
  79         n |= int16(buf[1]) << 8
  80         return
  81 }
  82
  83 // GetInt32 decodes a little-endian int32 from a byte slice.
  84 func GetInt32(buf []byte) (n int32) {
  85         _ = buf[3] // Force one bounds check. See: golang.org/issue/14808
  86         n |= int32(buf[0])
  87         n |= int32(buf[1]) << 8
  88         n |= int32(buf[2]) << 16
  89         n |= int32(buf[3]) << 24
  90         return
  91 }
  92
  93 // GetInt64 decodes a little-endian int64 from a byte slice.
  94 func GetInt64(buf []byte) (n int64) {
  95         _ = buf[7] // Force one bounds check. See: golang.org/issue/14808
  96         n |= int64(buf[0])
  97         n |= int64(buf[1]) << 8
  98         n |= int64(buf[2]) << 16
  99         n |= int64(buf[3]) << 24
 100         n |= int64(buf[4]) << 32
 101         n |= int64(buf[5]) << 40
 102         n |= int64(buf[6]) << 48
 103         n |= int64(buf[7]) << 56
 104         return
 105 }
 106
 107 // GetFloat32 decodes a little-endian float32 from a byte slice.
 108 func GetFloat32(buf []byte) float32 {
 109         x := GetUint32(buf)
 110         return math.Float32frombits(x)
 111 }
 112
 113 // GetFloat64 decodes a little-endian float64 from a byte slice.
 114 func GetFloat64(buf []byte) float64 {
 115         x := GetUint64(buf)
 116         return math.Float64frombits(x)
 117 }
 118
 119 // GetUOffsetT decodes a little-endian UOffsetT from a byte slice.
 120 func GetUOffsetT(buf []byte) UOffsetT {
 121         return UOffsetT(GetUint32(buf))
 122 }
 123
 124 // GetSOffsetT decodes a little-endian SOffsetT from a byte slice.
 125 func GetSOffsetT(buf []byte) SOffsetT {
 126         return SOffsetT(GetInt32(buf))
 127 }
 128
 129 // GetVOffsetT decodes a little-endian VOffsetT from a byte slice.
 130 func GetVOffsetT(buf []byte) VOffsetT {
 131         return VOffsetT(GetUint16(buf))
 132 }
 133
 134 // WriteByte encodes a little-endian uint8 into a byte slice.
 135 func WriteByte(buf []byte, n byte) {
 136         WriteUint8(buf, uint8(n))
 137 }
 138
 139 // WriteBool encodes a little-endian bool into a byte slice.
 140 func WriteBool(buf []byte, b bool) {
 141         buf[0] = 0
 142         if b {
 143                 buf[0] = 1
 144         }
 145 }
 146
 147 // WriteUint8 encodes a little-endian uint8 into a byte slice.
 148 func WriteUint8(buf []byte, n uint8) {
 149         buf[0] = byte(n)
 150 }
 151
 152 // WriteUint16 encodes a little-endian uint16 into a byte slice.
 153 func WriteUint16(buf []byte, n uint16) {
 154         _ = buf[1] // Force one bounds check. See: golang.org/issue/14808
 155         buf[0] = byte(n)
 156         buf[1] = byte(n >> 8)
 157 }
 158
 159 // WriteUint32 encodes a little-endian uint32 into a byte slice.
 160 func WriteUint32(buf []byte, n uint32) {
 161         _ = buf[3] // Force one bounds check. See: golang.org/issue/14808
 162         buf[0] = byte(n)
 163         buf[1] = byte(n >> 8)
 164         buf[2] = byte(n >> 16)
 165         buf[3] = byte(n >> 24)
 166 }
 167
 168 // WriteUint64 encodes a little-endian uint64 into a byte slice.
 169 func WriteUint64(buf []byte, n uint64) {
 170         _ = buf[7] // Force one bounds check. See: golang.org/issue/14808
 171         buf[0] = byte(n)
 172         buf[1] = byte(n >> 8)
 173         buf[2] = byte(n >> 16)
 174         buf[3] = byte(n >> 24)
 175         buf[4] = byte(n >> 32)
 176         buf[5] = byte(n >> 40)
 177         buf[6] = byte(n >> 48)
 178         buf[7] = byte(n >> 56)
 179 }
 180
 181 // WriteInt8 encodes a little-endian int8 into a byte slice.
 182 func WriteInt8(buf []byte, n int8) {
 183         buf[0] = byte(n)
 184 }
 185
 186 // WriteInt16 encodes a little-endian int16 into a byte slice.
 187 func WriteInt16(buf []byte, n int16) {
 188         _ = buf[1] // Force one bounds check. See: golang.org/issue/14808
 189         buf[0] = byte(n)
 190         buf[1] = byte(n >> 8)
 191 }
 192
 193 // WriteInt32 encodes a little-endian int32 into a byte slice.
 194 func WriteInt32(buf []byte, n int32) {
 195         _ = buf[3] // Force one bounds check. See: golang.org/issue/14808
 196         buf[0] = byte(n)
 197         buf[1] = byte(n >> 8)
 198         buf[2] = byte(n >> 16)
 199         buf[3] = byte(n >> 24)
 200 }
 201
 202 // WriteInt64 encodes a little-endian int64 into a byte slice.
 203 func WriteInt64(buf []byte, n int64) {
 204         _ = buf[7] // Force one bounds check. See: golang.org/issue/14808
 205         buf[0] = byte(n)
 206         buf[1] = byte(n >> 8)
 207         buf[2] = byte(n >> 16)
 208         buf[3] = byte(n >> 24)
 209         buf[4] = byte(n >> 32)
 210         buf[5] = byte(n >> 40)
 211         buf[6] = byte(n >> 48)
 212         buf[7] = byte(n >> 56)
 213 }
 214
 215 // WriteFloat32 encodes a little-endian float32 into a byte slice.
 216 func WriteFloat32(buf []byte, n float32) {
 217         WriteUint32(buf, math.Float32bits(n))
 218 }
 219
 220 // WriteFloat64 encodes a little-endian float64 into a byte slice.
 221 func WriteFloat64(buf []byte, n float64) {
 222         WriteUint64(buf, math.Float64bits(n))
 223 }
 224
 225 // WriteVOffsetT encodes a little-endian VOffsetT into a byte slice.
 226 func WriteVOffsetT(buf []byte, n VOffsetT) {
 227         WriteUint16(buf, uint16(n))
 228 }
 229
 230 // WriteSOffsetT encodes a little-endian SOffsetT into a byte slice.
 231 func WriteSOffsetT(buf []byte, n SOffsetT) {
 232         WriteInt32(buf, int32(n))
 233 }
 234
 235 // WriteUOffsetT encodes a little-endian UOffsetT into a byte slice.
 236 func WriteUOffsetT(buf []byte, n UOffsetT) {
 237         WriteUint32(buf, uint32(n))
 238 }