1 package flatbuffers 2 3 // Table wraps a byte slice and provides read access to its data. 4 // 5 // The variable `Pos` indicates the root of the FlatBuffers object therein. 6 type Table struct { 7 Bytes []byte 8 Pos UOffsetT // Always < 1<<31. 9 } 10 11 // Offset provides access into the Table's vtable. 12 // 13 // Fields which are deprecated are ignored by checking against the vtable's length. 14 func (t *Table) Offset(vtableOffset VOffsetT) VOffsetT { 15 vtable := UOffsetT(SOffsetT(t.Pos) - t.GetSOffsetT(t.Pos)) 16 if vtableOffset < t.GetVOffsetT(vtable) { 17 return t.GetVOffsetT(vtable + UOffsetT(vtableOffset)) 18 } 19 return 0 20 } 21 22 // Indirect retrieves the relative offset stored at `offset`. 23 func (t *Table) Indirect(off UOffsetT) UOffsetT { 24 return off + GetUOffsetT(t.Bytes[off:]) 25 } 26 27 // String gets a string from data stored inside the flatbuffer. 28 func (t *Table) String(off UOffsetT) string { 29 b := t.ByteVector(off) 30 return byteSliceToString(b) 31 } 32 33 // ByteVector gets a byte slice from data stored inside the flatbuffer. 34 func (t *Table) ByteVector(off UOffsetT) []byte { 35 off += GetUOffsetT(t.Bytes[off:]) 36 start := off + UOffsetT(SizeUOffsetT) 37 length := GetUOffsetT(t.Bytes[off:]) 38 return t.Bytes[start : start+length] 39 } 40 41 // VectorLen retrieves the length of the vector whose offset is stored at 42 // "off" in this object. 43 func (t *Table) VectorLen(off UOffsetT) int { 44 off += t.Pos 45 off += GetUOffsetT(t.Bytes[off:]) 46 return int(GetUOffsetT(t.Bytes[off:])) 47 } 48 49 // Vector retrieves the start of data of the vector whose offset is stored 50 // at "off" in this object. 51 func (t *Table) Vector(off UOffsetT) UOffsetT { 52 off += t.Pos 53 x := off + GetUOffsetT(t.Bytes[off:]) 54 // data starts after metadata containing the vector length 55 x += UOffsetT(SizeUOffsetT) 56 return x 57 } 58 59 // Union initializes any Table-derived type to point to the union at the given 60 // offset. 61 func (t *Table) Union(t2 *Table, off UOffsetT) { 62 off += t.Pos 63 t2.Pos = off + t.GetUOffsetT(off) 64 t2.Bytes = t.Bytes 65 } 66 67 // GetBool retrieves a bool at the given offset. 68 func (t *Table) GetBool(off UOffsetT) bool { 69 return GetBool(t.Bytes[off:]) 70 } 71 72 // GetByte retrieves a byte at the given offset. 73 func (t *Table) GetByte(off UOffsetT) byte { 74 return GetByte(t.Bytes[off:]) 75 } 76 77 // GetUint8 retrieves a uint8 at the given offset. 78 func (t *Table) GetUint8(off UOffsetT) uint8 { 79 return GetUint8(t.Bytes[off:]) 80 } 81 82 // GetUint16 retrieves a uint16 at the given offset. 83 func (t *Table) GetUint16(off UOffsetT) uint16 { 84 return GetUint16(t.Bytes[off:]) 85 } 86 87 // GetUint32 retrieves a uint32 at the given offset. 88 func (t *Table) GetUint32(off UOffsetT) uint32 { 89 return GetUint32(t.Bytes[off:]) 90 } 91 92 // GetUint64 retrieves a uint64 at the given offset. 93 func (t *Table) GetUint64(off UOffsetT) uint64 { 94 return GetUint64(t.Bytes[off:]) 95 } 96 97 // GetInt8 retrieves a int8 at the given offset. 98 func (t *Table) GetInt8(off UOffsetT) int8 { 99 return GetInt8(t.Bytes[off:]) 100 } 101 102 // GetInt16 retrieves a int16 at the given offset. 103 func (t *Table) GetInt16(off UOffsetT) int16 { 104 return GetInt16(t.Bytes[off:]) 105 } 106 107 // GetInt32 retrieves a int32 at the given offset. 108 func (t *Table) GetInt32(off UOffsetT) int32 { 109 return GetInt32(t.Bytes[off:]) 110 } 111 112 // GetInt64 retrieves a int64 at the given offset. 113 func (t *Table) GetInt64(off UOffsetT) int64 { 114 return GetInt64(t.Bytes[off:]) 115 } 116 117 // GetFloat32 retrieves a float32 at the given offset. 118 func (t *Table) GetFloat32(off UOffsetT) float32 { 119 return GetFloat32(t.Bytes[off:]) 120 } 121 122 // GetFloat64 retrieves a float64 at the given offset. 123 func (t *Table) GetFloat64(off UOffsetT) float64 { 124 return GetFloat64(t.Bytes[off:]) 125 } 126 127 // GetUOffsetT retrieves a UOffsetT at the given offset. 128 func (t *Table) GetUOffsetT(off UOffsetT) UOffsetT { 129 return GetUOffsetT(t.Bytes[off:]) 130 } 131 132 // GetVOffsetT retrieves a VOffsetT at the given offset. 133 func (t *Table) GetVOffsetT(off UOffsetT) VOffsetT { 134 return GetVOffsetT(t.Bytes[off:]) 135 } 136 137 // GetSOffsetT retrieves a SOffsetT at the given offset. 138 func (t *Table) GetSOffsetT(off UOffsetT) SOffsetT { 139 return GetSOffsetT(t.Bytes[off:]) 140 } 141 142 // GetBoolSlot retrieves the bool that the given vtable location 143 // points to. If the vtable value is zero, the default value `d` 144 // will be returned. 145 func (t *Table) GetBoolSlot(slot VOffsetT, d bool) bool { 146 off := t.Offset(slot) 147 if off == 0 { 148 return d 149 } 150 151 return t.GetBool(t.Pos + UOffsetT(off)) 152 } 153 154 // GetByteSlot retrieves the byte that the given vtable location 155 // points to. If the vtable value is zero, the default value `d` 156 // will be returned. 157 func (t *Table) GetByteSlot(slot VOffsetT, d byte) byte { 158 off := t.Offset(slot) 159 if off == 0 { 160 return d 161 } 162 163 return t.GetByte(t.Pos + UOffsetT(off)) 164 } 165 166 // GetInt8Slot retrieves the int8 that the given vtable location 167 // points to. If the vtable value is zero, the default value `d` 168 // will be returned. 169 func (t *Table) GetInt8Slot(slot VOffsetT, d int8) int8 { 170 off := t.Offset(slot) 171 if off == 0 { 172 return d 173 } 174 175 return t.GetInt8(t.Pos + UOffsetT(off)) 176 } 177 178 // GetUint8Slot retrieves the uint8 that the given vtable location 179 // points to. If the vtable value is zero, the default value `d` 180 // will be returned. 181 func (t *Table) GetUint8Slot(slot VOffsetT, d uint8) uint8 { 182 off := t.Offset(slot) 183 if off == 0 { 184 return d 185 } 186 187 return t.GetUint8(t.Pos + UOffsetT(off)) 188 } 189 190 // GetInt16Slot retrieves the int16 that the given vtable location 191 // points to. If the vtable value is zero, the default value `d` 192 // will be returned. 193 func (t *Table) GetInt16Slot(slot VOffsetT, d int16) int16 { 194 off := t.Offset(slot) 195 if off == 0 { 196 return d 197 } 198 199 return t.GetInt16(t.Pos + UOffsetT(off)) 200 } 201 202 // GetUint16Slot retrieves the uint16 that the given vtable location 203 // points to. If the vtable value is zero, the default value `d` 204 // will be returned. 205 func (t *Table) GetUint16Slot(slot VOffsetT, d uint16) uint16 { 206 off := t.Offset(slot) 207 if off == 0 { 208 return d 209 } 210 211 return t.GetUint16(t.Pos + UOffsetT(off)) 212 } 213 214 // GetInt32Slot retrieves the int32 that the given vtable location 215 // points to. If the vtable value is zero, the default value `d` 216 // will be returned. 217 func (t *Table) GetInt32Slot(slot VOffsetT, d int32) int32 { 218 off := t.Offset(slot) 219 if off == 0 { 220 return d 221 } 222 223 return t.GetInt32(t.Pos + UOffsetT(off)) 224 } 225 226 // GetUint32Slot retrieves the uint32 that the given vtable location 227 // points to. If the vtable value is zero, the default value `d` 228 // will be returned. 229 func (t *Table) GetUint32Slot(slot VOffsetT, d uint32) uint32 { 230 off := t.Offset(slot) 231 if off == 0 { 232 return d 233 } 234 235 return t.GetUint32(t.Pos + UOffsetT(off)) 236 } 237 238 // GetInt64Slot retrieves the int64 that the given vtable location 239 // points to. If the vtable value is zero, the default value `d` 240 // will be returned. 241 func (t *Table) GetInt64Slot(slot VOffsetT, d int64) int64 { 242 off := t.Offset(slot) 243 if off == 0 { 244 return d 245 } 246 247 return t.GetInt64(t.Pos + UOffsetT(off)) 248 } 249 250 // GetUint64Slot retrieves the uint64 that the given vtable location 251 // points to. If the vtable value is zero, the default value `d` 252 // will be returned. 253 func (t *Table) GetUint64Slot(slot VOffsetT, d uint64) uint64 { 254 off := t.Offset(slot) 255 if off == 0 { 256 return d 257 } 258 259 return t.GetUint64(t.Pos + UOffsetT(off)) 260 } 261 262 // GetFloat32Slot retrieves the float32 that the given vtable location 263 // points to. If the vtable value is zero, the default value `d` 264 // will be returned. 265 func (t *Table) GetFloat32Slot(slot VOffsetT, d float32) float32 { 266 off := t.Offset(slot) 267 if off == 0 { 268 return d 269 } 270 271 return t.GetFloat32(t.Pos + UOffsetT(off)) 272 } 273 274 // GetFloat64Slot retrieves the float64 that the given vtable location 275 // points to. If the vtable value is zero, the default value `d` 276 // will be returned. 277 func (t *Table) GetFloat64Slot(slot VOffsetT, d float64) float64 { 278 off := t.Offset(slot) 279 if off == 0 { 280 return d 281 } 282 283 return t.GetFloat64(t.Pos + UOffsetT(off)) 284 } 285 286 // GetVOffsetTSlot retrieves the VOffsetT that the given vtable location 287 // points to. If the vtable value is zero, the default value `d` 288 // will be returned. 289 func (t *Table) GetVOffsetTSlot(slot VOffsetT, d VOffsetT) VOffsetT { 290 off := t.Offset(slot) 291 if off == 0 { 292 return d 293 } 294 return VOffsetT(off) 295 } 296 297 // MutateBool updates a bool at the given offset. 298 func (t *Table) MutateBool(off UOffsetT, n bool) bool { 299 WriteBool(t.Bytes[off:], n) 300 return true 301 } 302 303 // MutateByte updates a Byte at the given offset. 304 func (t *Table) MutateByte(off UOffsetT, n byte) bool { 305 WriteByte(t.Bytes[off:], n) 306 return true 307 } 308 309 // MutateUint8 updates a Uint8 at the given offset. 310 func (t *Table) MutateUint8(off UOffsetT, n uint8) bool { 311 WriteUint8(t.Bytes[off:], n) 312 return true 313 } 314 315 // MutateUint16 updates a Uint16 at the given offset. 316 func (t *Table) MutateUint16(off UOffsetT, n uint16) bool { 317 WriteUint16(t.Bytes[off:], n) 318 return true 319 } 320 321 // MutateUint32 updates a Uint32 at the given offset. 322 func (t *Table) MutateUint32(off UOffsetT, n uint32) bool { 323 WriteUint32(t.Bytes[off:], n) 324 return true 325 } 326 327 // MutateUint64 updates a Uint64 at the given offset. 328 func (t *Table) MutateUint64(off UOffsetT, n uint64) bool { 329 WriteUint64(t.Bytes[off:], n) 330 return true 331 } 332 333 // MutateInt8 updates a Int8 at the given offset. 334 func (t *Table) MutateInt8(off UOffsetT, n int8) bool { 335 WriteInt8(t.Bytes[off:], n) 336 return true 337 } 338 339 // MutateInt16 updates a Int16 at the given offset. 340 func (t *Table) MutateInt16(off UOffsetT, n int16) bool { 341 WriteInt16(t.Bytes[off:], n) 342 return true 343 } 344 345 // MutateInt32 updates a Int32 at the given offset. 346 func (t *Table) MutateInt32(off UOffsetT, n int32) bool { 347 WriteInt32(t.Bytes[off:], n) 348 return true 349 } 350 351 // MutateInt64 updates a Int64 at the given offset. 352 func (t *Table) MutateInt64(off UOffsetT, n int64) bool { 353 WriteInt64(t.Bytes[off:], n) 354 return true 355 } 356 357 // MutateFloat32 updates a Float32 at the given offset. 358 func (t *Table) MutateFloat32(off UOffsetT, n float32) bool { 359 WriteFloat32(t.Bytes[off:], n) 360 return true 361 } 362 363 // MutateFloat64 updates a Float64 at the given offset. 364 func (t *Table) MutateFloat64(off UOffsetT, n float64) bool { 365 WriteFloat64(t.Bytes[off:], n) 366 return true 367 } 368 369 // MutateUOffsetT updates a UOffsetT at the given offset. 370 func (t *Table) MutateUOffsetT(off UOffsetT, n UOffsetT) bool { 371 WriteUOffsetT(t.Bytes[off:], n) 372 return true 373 } 374 375 // MutateVOffsetT updates a VOffsetT at the given offset. 376 func (t *Table) MutateVOffsetT(off UOffsetT, n VOffsetT) bool { 377 WriteVOffsetT(t.Bytes[off:], n) 378 return true 379 } 380 381 // MutateSOffsetT updates a SOffsetT at the given offset. 382 func (t *Table) MutateSOffsetT(off UOffsetT, n SOffsetT) bool { 383 WriteSOffsetT(t.Bytes[off:], n) 384 return true 385 } 386 387 // MutateBoolSlot updates the bool at given vtable location 388 func (t *Table) MutateBoolSlot(slot VOffsetT, n bool) bool { 389 if off := t.Offset(slot); off != 0 { 390 t.MutateBool(t.Pos+UOffsetT(off), n) 391 return true 392 } 393 394 return false 395 } 396 397 // MutateByteSlot updates the byte at given vtable location 398 func (t *Table) MutateByteSlot(slot VOffsetT, n byte) bool { 399 if off := t.Offset(slot); off != 0 { 400 t.MutateByte(t.Pos+UOffsetT(off), n) 401 return true 402 } 403 404 return false 405 } 406 407 // MutateInt8Slot updates the int8 at given vtable location 408 func (t *Table) MutateInt8Slot(slot VOffsetT, n int8) bool { 409 if off := t.Offset(slot); off != 0 { 410 t.MutateInt8(t.Pos+UOffsetT(off), n) 411 return true 412 } 413 414 return false 415 } 416 417 // MutateUint8Slot updates the uint8 at given vtable location 418 func (t *Table) MutateUint8Slot(slot VOffsetT, n uint8) bool { 419 if off := t.Offset(slot); off != 0 { 420 t.MutateUint8(t.Pos+UOffsetT(off), n) 421 return true 422 } 423 424 return false 425 } 426 427 // MutateInt16Slot updates the int16 at given vtable location 428 func (t *Table) MutateInt16Slot(slot VOffsetT, n int16) bool { 429 if off := t.Offset(slot); off != 0 { 430 t.MutateInt16(t.Pos+UOffsetT(off), n) 431 return true 432 } 433 434 return false 435 } 436 437 // MutateUint16Slot updates the uint16 at given vtable location 438 func (t *Table) MutateUint16Slot(slot VOffsetT, n uint16) bool { 439 if off := t.Offset(slot); off != 0 { 440 t.MutateUint16(t.Pos+UOffsetT(off), n) 441 return true 442 } 443 444 return false 445 } 446 447 // MutateInt32Slot updates the int32 at given vtable location 448 func (t *Table) MutateInt32Slot(slot VOffsetT, n int32) bool { 449 if off := t.Offset(slot); off != 0 { 450 t.MutateInt32(t.Pos+UOffsetT(off), n) 451 return true 452 } 453 454 return false 455 } 456 457 // MutateUint32Slot updates the uint32 at given vtable location 458 func (t *Table) MutateUint32Slot(slot VOffsetT, n uint32) bool { 459 if off := t.Offset(slot); off != 0 { 460 t.MutateUint32(t.Pos+UOffsetT(off), n) 461 return true 462 } 463 464 return false 465 } 466 467 // MutateInt64Slot updates the int64 at given vtable location 468 func (t *Table) MutateInt64Slot(slot VOffsetT, n int64) bool { 469 if off := t.Offset(slot); off != 0 { 470 t.MutateInt64(t.Pos+UOffsetT(off), n) 471 return true 472 } 473 474 return false 475 } 476 477 // MutateUint64Slot updates the uint64 at given vtable location 478 func (t *Table) MutateUint64Slot(slot VOffsetT, n uint64) bool { 479 if off := t.Offset(slot); off != 0 { 480 t.MutateUint64(t.Pos+UOffsetT(off), n) 481 return true 482 } 483 484 return false 485 } 486 487 // MutateFloat32Slot updates the float32 at given vtable location 488 func (t *Table) MutateFloat32Slot(slot VOffsetT, n float32) bool { 489 if off := t.Offset(slot); off != 0 { 490 t.MutateFloat32(t.Pos+UOffsetT(off), n) 491 return true 492 } 493 494 return false 495 } 496 497 // MutateFloat64Slot updates the float64 at given vtable location 498 func (t *Table) MutateFloat64Slot(slot VOffsetT, n float64) bool { 499 if off := t.Offset(slot); off != 0 { 500 t.MutateFloat64(t.Pos+UOffsetT(off), n) 501 return true 502 } 503 504 return false 505 } 506