• Home
  • Raw
  • Download

Lines Matching refs:b

29 	b := &Builder{}
30 b.Bytes = make([]byte, initialSize)
31 b.head = UOffsetT(initialSize)
32 b.minalign = 1
33 b.vtables = make([]UOffsetT, 0, 16) // sensible default capacity
35 return b
40 func (b *Builder) Reset() {
41 if b.Bytes != nil {
42 b.Bytes = b.Bytes[:cap(b.Bytes)]
45 if b.vtables != nil {
46 b.vtables = b.vtables[:0]
49 if b.vtable != nil {
50 b.vtable = b.vtable[:0]
53 b.head = UOffsetT(len(b.Bytes))
54 b.minalign = 1
55 b.nested = false
56 b.finished = false
62 func (b *Builder) FinishedBytes() []byte {
63 b.assertFinished()
64 return b.Bytes[b.Head():]
68 func (b *Builder) StartObject(numfields int) {
69 b.assertNotNested()
70 b.nested = true
73 if cap(b.vtable) < numfields || b.vtable == nil {
74 b.vtable = make([]UOffsetT, numfields)
76 b.vtable = b.vtable[:numfields]
77 for i := 0; i < len(b.vtable); i++ {
78 b.vtable[i] = 0
82 b.objectEnd = b.Offset()
83 b.minalign = 1
105 func (b *Builder) WriteVtable() (n UOffsetT) {
108 b.PrependSOffsetT(0)
110 objectOffset := b.Offset()
114 i := len(b.vtable) - 1;
115 for ; i >= 0 && b.vtable[i] == 0; i-- {}
116 b.vtable = b.vtable[:i + 1];
123 for i := len(b.vtables) - 1; i >= 0; i-- {
125 vt2Offset := b.vtables[i]
126 vt2Start := len(b.Bytes) - int(vt2Offset)
127 vt2Len := GetVOffsetT(b.Bytes[vt2Start:])
131 vt2 := b.Bytes[vt2Start+metadata : vt2End]
135 if vtableEqual(b.vtable, objectOffset, vt2) {
146 for i := len(b.vtable) - 1; i >= 0; i-- {
148 if b.vtable[i] != 0 {
151 off = objectOffset - b.vtable[i]
154 b.PrependVOffsetT(VOffsetT(off))
160 objectSize := objectOffset - b.objectEnd
161 b.PrependVOffsetT(VOffsetT(objectSize))
164 vBytes := (len(b.vtable) + VtableMetadataFields) * SizeVOffsetT
165 b.PrependVOffsetT(VOffsetT(vBytes))
169 objectStart := SOffsetT(len(b.Bytes)) - SOffsetT(objectOffset)
170 WriteSOffsetT(b.Bytes[objectStart:],
171 SOffsetT(b.Offset())-SOffsetT(objectOffset))
175 b.vtables = append(b.vtables, b.Offset())
179 objectStart := SOffsetT(len(b.Bytes)) - SOffsetT(objectOffset)
180 b.head = UOffsetT(objectStart)
184 WriteSOffsetT(b.Bytes[b.head:],
188 b.vtable = b.vtable[:0]
193 func (b *Builder) EndObject() UOffsetT {
194 b.assertNested()
195 n := b.WriteVtable()
196 b.nested = false
202 func (b *Builder) growByteBuffer() {
203 if (int64(len(b.Bytes)) & int64(0xC0000000)) != 0 {
206 newLen := len(b.Bytes) * 2
211 if cap(b.Bytes) >= newLen {
212 b.Bytes = b.Bytes[:newLen]
214 extension := make([]byte, newLen-len(b.Bytes))
215 b.Bytes = append(b.Bytes, extension...)
219 copy(b.Bytes[middle:], b.Bytes[:middle])
224 func (b *Builder) Head() UOffsetT {
225 return b.head
229 func (b *Builder) Offset() UOffsetT {
230 return UOffsetT(len(b.Bytes)) - b.head
234 func (b *Builder) Pad(n int) {
236 b.PlaceByte(0)
245 func (b *Builder) Prep(size, additionalBytes int) {
247 if size > b.minalign {
248 b.minalign = size
252 alignSize := (^(len(b.Bytes) - int(b.Head()) + additionalBytes)) + 1
256 for int(b.head) <= alignSize+size+additionalBytes {
257 oldBufSize := len(b.Bytes)
258 b.growByteBuffer()
259 b.head += UOffsetT(len(b.Bytes) - oldBufSize)
261 b.Pad(alignSize)
265 func (b *Builder) PrependSOffsetT(off SOffsetT) {
266 b.Prep(SizeSOffsetT, 0) // Ensure alignment is already done.
267 if !(UOffsetT(off) <= b.Offset()) {
270 off2 := SOffsetT(b.Offset()) - off + SOffsetT(SizeSOffsetT)
271 b.PlaceSOffsetT(off2)
275 func (b *Builder) PrependUOffsetT(off UOffsetT) {
276 b.Prep(SizeUOffsetT, 0) // Ensure alignment is already done.
277 if !(off <= b.Offset()) {
280 off2 := b.Offset() - off + UOffsetT(SizeUOffsetT)
281 b.PlaceUOffsetT(off2)
289 func (b *Builder) StartVector(elemSize, numElems, alignment int) UOffsetT {
290 b.assertNotNested()
291 b.nested = true
292 b.Prep(SizeUint32, elemSize*numElems)
293 b.Prep(alignment, elemSize*numElems) // Just in case alignment > int.
294 return b.Offset()
298 func (b *Builder) EndVector(vectorNumElems int) UOffsetT {
299 b.assertNested()
302 b.PlaceUOffsetT(UOffsetT(vectorNumElems))
304 b.nested = false
305 return b.Offset()
309 func (b *Builder) CreateString(s string) UOffsetT {
310 b.assertNotNested()
311 b.nested = true
313 b.Prep(int(SizeUOffsetT), (len(s)+1)*SizeByte)
314 b.PlaceByte(0)
318 b.head -= l
319 copy(b.Bytes[b.head:b.head+l], s)
321 return b.EndVector(len(s))
325 func (b *Builder) CreateByteString(s []byte) UOffsetT {
326 b.assertNotNested()
327 b.nested = true
329 b.Prep(int(SizeUOffsetT), (len(s)+1)*SizeByte)
330 b.PlaceByte(0)
334 b.head -= l
335 copy(b.Bytes[b.head:b.head+l], s)
337 return b.EndVector(len(s))
341 func (b *Builder) CreateByteVector(v []byte) UOffsetT {
342 b.assertNotNested()
343 b.nested = true
345 b.Prep(int(SizeUOffsetT), len(v)*SizeByte)
349 b.head -= l
350 copy(b.Bytes[b.head:b.head+l], v)
352 return b.EndVector(len(v))
355 func (b *Builder) assertNested() {
360 if !b.nested {
365 func (b *Builder) assertNotNested() {
374 if b.nested {
379 func (b *Builder) assertFinished() {
385 if !b.finished {
393 func (b *Builder) PrependBoolSlot(o int, x, d bool) {
402 b.PrependByteSlot(o, val, def)
408 func (b *Builder) PrependByteSlot(o int, x, d byte) {
410 b.PrependByte(x)
411 b.Slot(o)
418 func (b *Builder) PrependUint8Slot(o int, x, d uint8) {
420 b.PrependUint8(x)
421 b.Slot(o)
428 func (b *Builder) PrependUint16Slot(o int, x, d uint16) {
430 b.PrependUint16(x)
431 b.Slot(o)
438 func (b *Builder) PrependUint32Slot(o int, x, d uint32) {
440 b.PrependUint32(x)
441 b.Slot(o)
448 func (b *Builder) PrependUint64Slot(o int, x, d uint64) {
450 b.PrependUint64(x)
451 b.Slot(o)
458 func (b *Builder) PrependInt8Slot(o int, x, d int8) {
460 b.PrependInt8(x)
461 b.Slot(o)
468 func (b *Builder) PrependInt16Slot(o int, x, d int16) {
470 b.PrependInt16(x)
471 b.Slot(o)
478 func (b *Builder) PrependInt32Slot(o int, x, d int32) {
480 b.PrependInt32(x)
481 b.Slot(o)
488 func (b *Builder) PrependInt64Slot(o int, x, d int64) {
490 b.PrependInt64(x)
491 b.Slot(o)
498 func (b *Builder) PrependFloat32Slot(o int, x, d float32) {
500 b.PrependFloat32(x)
501 b.Slot(o)
508 func (b *Builder) PrependFloat64Slot(o int, x, d float64) {
510 b.PrependFloat64(x)
511 b.Slot(o)
518 func (b *Builder) PrependUOffsetTSlot(o int, x, d UOffsetT) {
520 b.PrependUOffsetT(x)
521 b.Slot(o)
528 func (b *Builder) PrependStructSlot(voffset int, x, d UOffsetT) {
530 b.assertNested()
531 if x != b.Offset() {
534 b.Slot(voffset)
539 func (b *Builder) Slot(slotnum int) {
540 b.vtable[slotnum] = UOffsetT(b.Offset())
544 func (b *Builder) Finish(rootTable UOffsetT) {
545 b.assertNotNested()
546 b.Prep(b.minalign, SizeUOffsetT)
547 b.PrependUOffsetT(rootTable)
548 b.finished = true
552 func vtableEqual(a []UOffsetT, objectStart UOffsetT, b []byte) bool {
553 if len(a)*SizeVOffsetT != len(b) {
558 x := GetVOffsetT(b[i*SizeVOffsetT : (i+1)*SizeVOffsetT])
575 func (b *Builder) PrependBool(x bool) {
576 b.Prep(SizeBool, 0)
577 b.PlaceBool(x)
582 func (b *Builder) PrependUint8(x uint8) {
583 b.Prep(SizeUint8, 0)
584 b.PlaceUint8(x)
589 func (b *Builder) PrependUint16(x uint16) {
590 b.Prep(SizeUint16, 0)
591 b.PlaceUint16(x)
596 func (b *Builder) PrependUint32(x uint32) {
597 b.Prep(SizeUint32, 0)
598 b.PlaceUint32(x)
603 func (b *Builder) PrependUint64(x uint64) {
604 b.Prep(SizeUint64, 0)
605 b.PlaceUint64(x)
610 func (b *Builder) PrependInt8(x int8) {
611 b.Prep(SizeInt8, 0)
612 b.PlaceInt8(x)
617 func (b *Builder) PrependInt16(x int16) {
618 b.Prep(SizeInt16, 0)
619 b.PlaceInt16(x)
624 func (b *Builder) PrependInt32(x int32) {
625 b.Prep(SizeInt32, 0)
626 b.PlaceInt32(x)
631 func (b *Builder) PrependInt64(x int64) {
632 b.Prep(SizeInt64, 0)
633 b.PlaceInt64(x)
638 func (b *Builder) PrependFloat32(x float32) {
639 b.Prep(SizeFloat32, 0)
640 b.PlaceFloat32(x)
645 func (b *Builder) PrependFloat64(x float64) {
646 b.Prep(SizeFloat64, 0)
647 b.PlaceFloat64(x)
652 func (b *Builder) PrependByte(x byte) {
653 b.Prep(SizeByte, 0)
654 b.PlaceByte(x)
659 func (b *Builder) PrependVOffsetT(x VOffsetT) {
660 b.Prep(SizeVOffsetT, 0)
661 b.PlaceVOffsetT(x)
665 func (b *Builder) PlaceBool(x bool) {
666 b.head -= UOffsetT(SizeBool)
667 WriteBool(b.Bytes[b.head:], x)
671 func (b *Builder) PlaceUint8(x uint8) {
672 b.head -= UOffsetT(SizeUint8)
673 WriteUint8(b.Bytes[b.head:], x)
677 func (b *Builder) PlaceUint16(x uint16) {
678 b.head -= UOffsetT(SizeUint16)
679 WriteUint16(b.Bytes[b.head:], x)
683 func (b *Builder) PlaceUint32(x uint32) {
684 b.head -= UOffsetT(SizeUint32)
685 WriteUint32(b.Bytes[b.head:], x)
689 func (b *Builder) PlaceUint64(x uint64) {
690 b.head -= UOffsetT(SizeUint64)
691 WriteUint64(b.Bytes[b.head:], x)
695 func (b *Builder) PlaceInt8(x int8) {
696 b.head -= UOffsetT(SizeInt8)
697 WriteInt8(b.Bytes[b.head:], x)
701 func (b *Builder) PlaceInt16(x int16) {
702 b.head -= UOffsetT(SizeInt16)
703 WriteInt16(b.Bytes[b.head:], x)
707 func (b *Builder) PlaceInt32(x int32) {
708 b.head -= UOffsetT(SizeInt32)
709 WriteInt32(b.Bytes[b.head:], x)
713 func (b *Builder) PlaceInt64(x int64) {
714 b.head -= UOffsetT(SizeInt64)
715 WriteInt64(b.Bytes[b.head:], x)
719 func (b *Builder) PlaceFloat32(x float32) {
720 b.head -= UOffsetT(SizeFloat32)
721 WriteFloat32(b.Bytes[b.head:], x)
725 func (b *Builder) PlaceFloat64(x float64) {
726 b.head -= UOffsetT(SizeFloat64)
727 WriteFloat64(b.Bytes[b.head:], x)
731 func (b *Builder) PlaceByte(x byte) {
732 b.head -= UOffsetT(SizeByte)
733 WriteByte(b.Bytes[b.head:], x)
737 func (b *Builder) PlaceVOffsetT(x VOffsetT) {
738 b.head -= UOffsetT(SizeVOffsetT)
739 WriteVOffsetT(b.Bytes[b.head:], x)
743 func (b *Builder) PlaceSOffsetT(x SOffsetT) {
744 b.head -= UOffsetT(SizeSOffsetT)
745 WriteSOffsetT(b.Bytes[b.head:], x)
749 func (b *Builder) PlaceUOffsetT(x UOffsetT) {
750 b.head -= UOffsetT(SizeUOffsetT)
751 WriteUOffsetT(b.Bytes[b.head:], x)