811 lines
26 KiB
Python
811 lines
26 KiB
Python
# Copyright 2014 Google Inc. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from . import number_types as N
|
|
from .number_types import (UOffsetTFlags, SOffsetTFlags, VOffsetTFlags)
|
|
|
|
from . import encode
|
|
from . import packer
|
|
|
|
from . import compat
|
|
from .compat import range_func
|
|
from .compat import memoryview_type
|
|
from .compat import import_numpy, NumpyRequiredForThisFeature
|
|
|
|
import warnings
|
|
|
|
np = import_numpy()
|
|
## @file
|
|
## @addtogroup flatbuffers_python_api
|
|
## @{
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
class OffsetArithmeticError(RuntimeError):
|
|
"""
|
|
Error caused by an Offset arithmetic error. Probably caused by bad
|
|
writing of fields. This is considered an unreachable situation in
|
|
normal circumstances.
|
|
"""
|
|
pass
|
|
|
|
|
|
class IsNotNestedError(RuntimeError):
|
|
"""
|
|
Error caused by using a Builder to write Object data when not inside
|
|
an Object.
|
|
"""
|
|
pass
|
|
|
|
|
|
class IsNestedError(RuntimeError):
|
|
"""
|
|
Error caused by using a Builder to begin an Object when an Object is
|
|
already being built.
|
|
"""
|
|
pass
|
|
|
|
|
|
class StructIsNotInlineError(RuntimeError):
|
|
"""
|
|
Error caused by using a Builder to write a Struct at a location that
|
|
is not the current Offset.
|
|
"""
|
|
pass
|
|
|
|
|
|
class BuilderSizeError(RuntimeError):
|
|
"""
|
|
Error caused by causing a Builder to exceed the hardcoded limit of 2
|
|
gigabytes.
|
|
"""
|
|
pass
|
|
|
|
class BuilderNotFinishedError(RuntimeError):
|
|
"""
|
|
Error caused by not calling `Finish` before calling `Output`.
|
|
"""
|
|
pass
|
|
|
|
class EndVectorLengthMismatched(RuntimeError):
|
|
"""
|
|
The number of elements passed to EndVector does not match the number
|
|
specified in StartVector.
|
|
"""
|
|
pass
|
|
|
|
|
|
# VtableMetadataFields is the count of metadata fields in each vtable.
|
|
VtableMetadataFields = 2
|
|
## @endcond
|
|
|
|
class Builder(object):
|
|
""" A Builder is used to construct one or more FlatBuffers.
|
|
|
|
Typically, Builder objects will be used from code generated by the `flatc`
|
|
compiler.
|
|
|
|
A Builder constructs byte buffers in a last-first manner for simplicity and
|
|
performance during reading.
|
|
|
|
Internally, a Builder is a state machine for creating FlatBuffer objects.
|
|
|
|
It holds the following internal state:
|
|
- Bytes: an array of bytes.
|
|
- current_vtable: a list of integers.
|
|
- vtables: a hash of vtable entries.
|
|
|
|
Attributes:
|
|
Bytes: The internal `bytearray` for the Builder.
|
|
finished: A boolean determining if the Builder has been finalized.
|
|
"""
|
|
|
|
## @cond FLATBUFFERS_INTENRAL
|
|
__slots__ = ("Bytes", "current_vtable", "head", "minalign", "objectEnd",
|
|
"vtables", "nested", "forceDefaults", "finished", "vectorNumElems",
|
|
"sharedStrings")
|
|
|
|
"""Maximum buffer size constant, in bytes.
|
|
|
|
Builder will never allow it's buffer grow over this size.
|
|
Currently equals 2Gb.
|
|
"""
|
|
MAX_BUFFER_SIZE = 2**31
|
|
## @endcond
|
|
|
|
def __init__(self, initialSize=1024):
|
|
"""Initializes a Builder of size `initial_size`.
|
|
|
|
The internal buffer is grown as needed.
|
|
"""
|
|
|
|
if not (0 <= initialSize <= Builder.MAX_BUFFER_SIZE):
|
|
msg = "flatbuffers: Cannot create Builder larger than 2 gigabytes."
|
|
raise BuilderSizeError(msg)
|
|
|
|
self.Bytes = bytearray(initialSize)
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.current_vtable = None
|
|
self.head = UOffsetTFlags.py_type(initialSize)
|
|
self.minalign = 1
|
|
self.objectEnd = None
|
|
self.vtables = {}
|
|
self.nested = False
|
|
self.forceDefaults = False
|
|
self.sharedStrings = {}
|
|
## @endcond
|
|
self.finished = False
|
|
|
|
def Output(self):
|
|
"""Return the portion of the buffer that has been used for writing data.
|
|
|
|
This is the typical way to access the FlatBuffer data inside the
|
|
builder. If you try to access `Builder.Bytes` directly, you would need
|
|
to manually index it with `Head()`, since the buffer is constructed
|
|
backwards.
|
|
|
|
It raises BuilderNotFinishedError if the buffer has not been finished
|
|
with `Finish`.
|
|
"""
|
|
|
|
if not self.finished:
|
|
raise BuilderNotFinishedError()
|
|
|
|
return self.Bytes[self.Head():]
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def StartObject(self, numfields):
|
|
"""StartObject initializes bookkeeping for writing a new object."""
|
|
|
|
self.assertNotNested()
|
|
|
|
# use 32-bit offsets so that arithmetic doesn't overflow.
|
|
self.current_vtable = [0 for _ in range_func(numfields)]
|
|
self.objectEnd = self.Offset()
|
|
self.nested = True
|
|
|
|
def WriteVtable(self):
|
|
"""
|
|
WriteVtable serializes the vtable for the current object, if needed.
|
|
|
|
Before writing out the vtable, this checks pre-existing vtables for
|
|
equality to this one. If an equal vtable is found, point the object to
|
|
the existing vtable and return.
|
|
|
|
Because vtable values are sensitive to alignment of object data, not
|
|
all logically-equal vtables will be deduplicated.
|
|
|
|
A vtable has the following format:
|
|
<VOffsetT: size of the vtable in bytes, including this value>
|
|
<VOffsetT: size of the object in bytes, including the vtable offset>
|
|
<VOffsetT: offset for a field> * N, where N is the number of fields
|
|
in the schema for this type. Includes deprecated fields.
|
|
Thus, a vtable is made of 2 + N elements, each VOffsetT bytes wide.
|
|
|
|
An object has the following format:
|
|
<SOffsetT: offset to this object's vtable (may be negative)>
|
|
<byte: data>+
|
|
"""
|
|
|
|
# Prepend a zero scalar to the object. Later in this function we'll
|
|
# write an offset here that points to the object's vtable:
|
|
self.PrependSOffsetTRelative(0)
|
|
|
|
objectOffset = self.Offset()
|
|
|
|
vtKey = []
|
|
trim = True
|
|
for elem in reversed(self.current_vtable):
|
|
if elem == 0:
|
|
if trim:
|
|
continue
|
|
else:
|
|
elem = objectOffset - elem
|
|
trim = False
|
|
|
|
vtKey.append(elem)
|
|
|
|
vtKey = tuple(vtKey)
|
|
vt2Offset = self.vtables.get(vtKey)
|
|
if vt2Offset is None:
|
|
# Did not find a vtable, so write this one to the buffer.
|
|
|
|
# Write out the current vtable in reverse , because
|
|
# serialization occurs in last-first order:
|
|
i = len(self.current_vtable) - 1
|
|
trailing = 0
|
|
trim = True
|
|
while i >= 0:
|
|
off = 0
|
|
elem = self.current_vtable[i]
|
|
i -= 1
|
|
|
|
if elem == 0:
|
|
if trim:
|
|
trailing += 1
|
|
continue
|
|
else:
|
|
# Forward reference to field;
|
|
# use 32bit number to ensure no overflow:
|
|
off = objectOffset - elem
|
|
trim = False
|
|
|
|
self.PrependVOffsetT(off)
|
|
|
|
# The two metadata fields are written last.
|
|
|
|
# First, store the object bytesize:
|
|
objectSize = UOffsetTFlags.py_type(objectOffset - self.objectEnd)
|
|
self.PrependVOffsetT(VOffsetTFlags.py_type(objectSize))
|
|
|
|
# Second, store the vtable bytesize:
|
|
vBytes = len(self.current_vtable) - trailing + VtableMetadataFields
|
|
vBytes *= N.VOffsetTFlags.bytewidth
|
|
self.PrependVOffsetT(VOffsetTFlags.py_type(vBytes))
|
|
|
|
# Next, write the offset to the new vtable in the
|
|
# already-allocated SOffsetT at the beginning of this object:
|
|
objectStart = SOffsetTFlags.py_type(len(self.Bytes) - objectOffset)
|
|
encode.Write(packer.soffset, self.Bytes, objectStart,
|
|
SOffsetTFlags.py_type(self.Offset() - objectOffset))
|
|
|
|
# Finally, store this vtable in memory for future
|
|
# deduplication:
|
|
self.vtables[vtKey] = self.Offset()
|
|
else:
|
|
# Found a duplicate vtable.
|
|
objectStart = SOffsetTFlags.py_type(len(self.Bytes) - objectOffset)
|
|
self.head = UOffsetTFlags.py_type(objectStart)
|
|
|
|
# Write the offset to the found vtable in the
|
|
# already-allocated SOffsetT at the beginning of this object:
|
|
encode.Write(packer.soffset, self.Bytes, self.Head(),
|
|
SOffsetTFlags.py_type(vt2Offset - objectOffset))
|
|
|
|
self.current_vtable = None
|
|
return objectOffset
|
|
|
|
def EndObject(self):
|
|
"""EndObject writes data necessary to finish object construction."""
|
|
self.assertNested()
|
|
self.nested = False
|
|
return self.WriteVtable()
|
|
|
|
def growByteBuffer(self):
|
|
"""Doubles the size of the byteslice, and copies the old data towards
|
|
the end of the new buffer (since we build the buffer backwards)."""
|
|
if len(self.Bytes) == Builder.MAX_BUFFER_SIZE:
|
|
msg = "flatbuffers: cannot grow buffer beyond 2 gigabytes"
|
|
raise BuilderSizeError(msg)
|
|
|
|
newSize = min(len(self.Bytes) * 2, Builder.MAX_BUFFER_SIZE)
|
|
if newSize == 0:
|
|
newSize = 1
|
|
bytes2 = bytearray(newSize)
|
|
bytes2[newSize-len(self.Bytes):] = self.Bytes
|
|
self.Bytes = bytes2
|
|
## @endcond
|
|
|
|
def Head(self):
|
|
"""Get the start of useful data in the underlying byte buffer.
|
|
|
|
Note: unlike other functions, this value is interpreted as from the
|
|
left.
|
|
"""
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
return self.head
|
|
## @endcond
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def Offset(self):
|
|
"""Offset relative to the end of the buffer."""
|
|
return UOffsetTFlags.py_type(len(self.Bytes) - self.Head())
|
|
|
|
def Pad(self, n):
|
|
"""Pad places zeros at the current offset."""
|
|
for i in range_func(n):
|
|
self.Place(0, N.Uint8Flags)
|
|
|
|
def Prep(self, size, additionalBytes):
|
|
"""
|
|
Prep prepares to write an element of `size` after `additional_bytes`
|
|
have been written, e.g. if you write a string, you need to align
|
|
such the int length field is aligned to SizeInt32, and the string
|
|
data follows it directly.
|
|
If all you need to do is align, `additionalBytes` will be 0.
|
|
"""
|
|
|
|
# Track the biggest thing we've ever aligned to.
|
|
if size > self.minalign:
|
|
self.minalign = size
|
|
|
|
# Find the amount of alignment needed such that `size` is properly
|
|
# aligned after `additionalBytes`:
|
|
alignSize = (~(len(self.Bytes) - self.Head() + additionalBytes)) + 1
|
|
alignSize &= (size - 1)
|
|
|
|
# Reallocate the buffer if needed:
|
|
while self.Head() < alignSize+size+additionalBytes:
|
|
oldBufSize = len(self.Bytes)
|
|
self.growByteBuffer()
|
|
updated_head = self.head + len(self.Bytes) - oldBufSize
|
|
self.head = UOffsetTFlags.py_type(updated_head)
|
|
self.Pad(alignSize)
|
|
|
|
def PrependSOffsetTRelative(self, off):
|
|
"""
|
|
PrependSOffsetTRelative prepends an SOffsetT, relative to where it
|
|
will be written.
|
|
"""
|
|
|
|
# Ensure alignment is already done:
|
|
self.Prep(N.SOffsetTFlags.bytewidth, 0)
|
|
if not (off <= self.Offset()):
|
|
msg = "flatbuffers: Offset arithmetic error."
|
|
raise OffsetArithmeticError(msg)
|
|
off2 = self.Offset() - off + N.SOffsetTFlags.bytewidth
|
|
self.PlaceSOffsetT(off2)
|
|
## @endcond
|
|
|
|
def PrependUOffsetTRelative(self, off):
|
|
"""Prepends an unsigned offset into vector data, relative to where it
|
|
will be written.
|
|
"""
|
|
|
|
# Ensure alignment is already done:
|
|
self.Prep(N.UOffsetTFlags.bytewidth, 0)
|
|
if not (off <= self.Offset()):
|
|
msg = "flatbuffers: Offset arithmetic error."
|
|
raise OffsetArithmeticError(msg)
|
|
off2 = self.Offset() - off + N.UOffsetTFlags.bytewidth
|
|
self.PlaceUOffsetT(off2)
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def StartVector(self, elemSize, numElems, alignment):
|
|
"""
|
|
StartVector initializes bookkeeping for writing a new vector.
|
|
|
|
A vector has the following format:
|
|
- <UOffsetT: number of elements in this vector>
|
|
- <T: data>+, where T is the type of elements of this vector.
|
|
"""
|
|
|
|
self.assertNotNested()
|
|
self.nested = True
|
|
self.vectorNumElems = numElems
|
|
self.Prep(N.Uint32Flags.bytewidth, elemSize*numElems)
|
|
self.Prep(alignment, elemSize*numElems) # In case alignment > int.
|
|
return self.Offset()
|
|
## @endcond
|
|
|
|
def EndVector(self, numElems = None):
|
|
"""EndVector writes data necessary to finish vector construction."""
|
|
|
|
self.assertNested()
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.nested = False
|
|
## @endcond
|
|
|
|
if numElems:
|
|
warnings.warn("numElems is deprecated.",
|
|
DeprecationWarning, stacklevel=2)
|
|
if numElems != self.vectorNumElems:
|
|
raise EndVectorLengthMismatched();
|
|
|
|
# we already made space for this, so write without PrependUint32
|
|
self.PlaceUOffsetT(self.vectorNumElems)
|
|
self.vectorNumElems = None
|
|
return self.Offset()
|
|
|
|
def CreateSharedString(self, s, encoding='utf-8', errors='strict'):
|
|
"""
|
|
CreateSharedString checks if the string is already written to the buffer
|
|
before calling CreateString.
|
|
"""
|
|
|
|
if s in self.sharedStrings:
|
|
return self.sharedStrings[s]
|
|
|
|
off = self.CreateString(s, encoding, errors)
|
|
self.sharedStrings[s] = off
|
|
|
|
return off
|
|
|
|
def CreateString(self, s, encoding='utf-8', errors='strict'):
|
|
"""CreateString writes a null-terminated byte string as a vector."""
|
|
|
|
self.assertNotNested()
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.nested = True
|
|
## @endcond
|
|
|
|
if isinstance(s, compat.string_types):
|
|
x = s.encode(encoding, errors)
|
|
elif isinstance(s, compat.binary_types):
|
|
x = s
|
|
else:
|
|
raise TypeError("non-string passed to CreateString")
|
|
|
|
self.Prep(N.UOffsetTFlags.bytewidth, (len(x)+1)*N.Uint8Flags.bytewidth)
|
|
self.Place(0, N.Uint8Flags)
|
|
|
|
l = UOffsetTFlags.py_type(len(s))
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.head = UOffsetTFlags.py_type(self.Head() - l)
|
|
## @endcond
|
|
self.Bytes[self.Head():self.Head()+l] = x
|
|
|
|
self.vectorNumElems = len(x)
|
|
return self.EndVector()
|
|
|
|
def CreateByteVector(self, x):
|
|
"""CreateString writes a byte vector."""
|
|
|
|
self.assertNotNested()
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.nested = True
|
|
## @endcond
|
|
|
|
if not isinstance(x, compat.binary_types):
|
|
raise TypeError("non-byte vector passed to CreateByteVector")
|
|
|
|
self.Prep(N.UOffsetTFlags.bytewidth, len(x)*N.Uint8Flags.bytewidth)
|
|
|
|
l = UOffsetTFlags.py_type(len(x))
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.head = UOffsetTFlags.py_type(self.Head() - l)
|
|
## @endcond
|
|
self.Bytes[self.Head():self.Head()+l] = x
|
|
|
|
self.vectorNumElems = len(x)
|
|
return self.EndVector()
|
|
|
|
def CreateNumpyVector(self, x):
|
|
"""CreateNumpyVector writes a numpy array into the buffer."""
|
|
|
|
if np is None:
|
|
# Numpy is required for this feature
|
|
raise NumpyRequiredForThisFeature("Numpy was not found.")
|
|
|
|
if not isinstance(x, np.ndarray):
|
|
raise TypeError("non-numpy-ndarray passed to CreateNumpyVector")
|
|
|
|
if x.dtype.kind not in ['b', 'i', 'u', 'f']:
|
|
raise TypeError("numpy-ndarray holds elements of unsupported datatype")
|
|
|
|
if x.ndim > 1:
|
|
raise TypeError("multidimensional-ndarray passed to CreateNumpyVector")
|
|
|
|
self.StartVector(x.itemsize, x.size, x.dtype.alignment)
|
|
|
|
# Ensure little endian byte ordering
|
|
if x.dtype.str[0] == "<":
|
|
x_lend = x
|
|
else:
|
|
x_lend = x.byteswap(inplace=False)
|
|
|
|
# Calculate total length
|
|
l = UOffsetTFlags.py_type(x_lend.itemsize * x_lend.size)
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
self.head = UOffsetTFlags.py_type(self.Head() - l)
|
|
## @endcond
|
|
|
|
# tobytes ensures c_contiguous ordering
|
|
self.Bytes[self.Head():self.Head()+l] = x_lend.tobytes(order='C')
|
|
|
|
self.vectorNumElems = x.size
|
|
return self.EndVector()
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def assertNested(self):
|
|
"""
|
|
Check that we are in the process of building an object.
|
|
"""
|
|
|
|
if not self.nested:
|
|
raise IsNotNestedError()
|
|
|
|
def assertNotNested(self):
|
|
"""
|
|
Check that no other objects are being built while making this
|
|
object. If not, raise an exception.
|
|
"""
|
|
|
|
if self.nested:
|
|
raise IsNestedError()
|
|
|
|
def assertStructIsInline(self, obj):
|
|
"""
|
|
Structs are always stored inline, so need to be created right
|
|
where they are used. You'll get this error if you created it
|
|
elsewhere.
|
|
"""
|
|
|
|
N.enforce_number(obj, N.UOffsetTFlags)
|
|
if obj != self.Offset():
|
|
msg = ("flatbuffers: Tried to write a Struct at an Offset that "
|
|
"is different from the current Offset of the Builder.")
|
|
raise StructIsNotInlineError(msg)
|
|
|
|
def Slot(self, slotnum):
|
|
"""
|
|
Slot sets the vtable key `voffset` to the current location in the
|
|
buffer.
|
|
|
|
"""
|
|
self.assertNested()
|
|
self.current_vtable[slotnum] = self.Offset()
|
|
## @endcond
|
|
|
|
def __Finish(self, rootTable, sizePrefix, file_identifier=None):
|
|
"""Finish finalizes a buffer, pointing to the given `rootTable`."""
|
|
N.enforce_number(rootTable, N.UOffsetTFlags)
|
|
|
|
prepSize = N.UOffsetTFlags.bytewidth
|
|
if file_identifier is not None:
|
|
prepSize += N.Int32Flags.bytewidth
|
|
if sizePrefix:
|
|
prepSize += N.Int32Flags.bytewidth
|
|
self.Prep(self.minalign, prepSize)
|
|
|
|
if file_identifier is not None:
|
|
self.Prep(N.UOffsetTFlags.bytewidth, encode.FILE_IDENTIFIER_LENGTH)
|
|
|
|
# Convert bytes object file_identifier to an array of 4 8-bit integers,
|
|
# and use big-endian to enforce size compliance.
|
|
# https://docs.python.org/2/library/struct.html#format-characters
|
|
file_identifier = N.struct.unpack(">BBBB", file_identifier)
|
|
for i in range(encode.FILE_IDENTIFIER_LENGTH-1, -1, -1):
|
|
# Place the bytes of the file_identifer in reverse order:
|
|
self.Place(file_identifier[i], N.Uint8Flags)
|
|
|
|
self.PrependUOffsetTRelative(rootTable)
|
|
if sizePrefix:
|
|
size = len(self.Bytes) - self.Head()
|
|
N.enforce_number(size, N.Int32Flags)
|
|
self.PrependInt32(size)
|
|
self.finished = True
|
|
return self.Head()
|
|
|
|
def Finish(self, rootTable, file_identifier=None):
|
|
"""Finish finalizes a buffer, pointing to the given `rootTable`."""
|
|
return self.__Finish(rootTable, False, file_identifier=file_identifier)
|
|
|
|
def FinishSizePrefixed(self, rootTable, file_identifier=None):
|
|
"""
|
|
Finish finalizes a buffer, pointing to the given `rootTable`,
|
|
with the size prefixed.
|
|
"""
|
|
return self.__Finish(rootTable, True, file_identifier=file_identifier)
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def Prepend(self, flags, off):
|
|
self.Prep(flags.bytewidth, 0)
|
|
self.Place(off, flags)
|
|
|
|
def PrependSlot(self, flags, o, x, d):
|
|
if x is not None:
|
|
N.enforce_number(x, flags)
|
|
if d is not None:
|
|
N.enforce_number(d, flags)
|
|
if x != d or (self.forceDefaults and d is not None):
|
|
self.Prepend(flags, x)
|
|
self.Slot(o)
|
|
|
|
def PrependBoolSlot(self, *args): self.PrependSlot(N.BoolFlags, *args)
|
|
|
|
def PrependByteSlot(self, *args): self.PrependSlot(N.Uint8Flags, *args)
|
|
|
|
def PrependUint8Slot(self, *args): self.PrependSlot(N.Uint8Flags, *args)
|
|
|
|
def PrependUint16Slot(self, *args): self.PrependSlot(N.Uint16Flags, *args)
|
|
|
|
def PrependUint32Slot(self, *args): self.PrependSlot(N.Uint32Flags, *args)
|
|
|
|
def PrependUint64Slot(self, *args): self.PrependSlot(N.Uint64Flags, *args)
|
|
|
|
def PrependInt8Slot(self, *args): self.PrependSlot(N.Int8Flags, *args)
|
|
|
|
def PrependInt16Slot(self, *args): self.PrependSlot(N.Int16Flags, *args)
|
|
|
|
def PrependInt32Slot(self, *args): self.PrependSlot(N.Int32Flags, *args)
|
|
|
|
def PrependInt64Slot(self, *args): self.PrependSlot(N.Int64Flags, *args)
|
|
|
|
def PrependFloat32Slot(self, *args): self.PrependSlot(N.Float32Flags,
|
|
*args)
|
|
|
|
def PrependFloat64Slot(self, *args): self.PrependSlot(N.Float64Flags,
|
|
*args)
|
|
|
|
def PrependUOffsetTRelativeSlot(self, o, x, d):
|
|
"""
|
|
PrependUOffsetTRelativeSlot prepends an UOffsetT onto the object at
|
|
vtable slot `o`. If value `x` equals default `d`, then the slot will
|
|
be set to zero and no other data will be written.
|
|
"""
|
|
|
|
if x != d or self.forceDefaults:
|
|
self.PrependUOffsetTRelative(x)
|
|
self.Slot(o)
|
|
|
|
def PrependStructSlot(self, v, x, d):
|
|
"""
|
|
PrependStructSlot prepends a struct onto the object at vtable slot `o`.
|
|
Structs are stored inline, so nothing additional is being added.
|
|
In generated code, `d` is always 0.
|
|
"""
|
|
|
|
N.enforce_number(d, N.UOffsetTFlags)
|
|
if x != d:
|
|
self.assertStructIsInline(x)
|
|
self.Slot(v)
|
|
|
|
## @endcond
|
|
|
|
def PrependBool(self, x):
|
|
"""Prepend a `bool` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.BoolFlags, x)
|
|
|
|
def PrependByte(self, x):
|
|
"""Prepend a `byte` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Uint8Flags, x)
|
|
|
|
def PrependUint8(self, x):
|
|
"""Prepend an `uint8` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Uint8Flags, x)
|
|
|
|
def PrependUint16(self, x):
|
|
"""Prepend an `uint16` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Uint16Flags, x)
|
|
|
|
def PrependUint32(self, x):
|
|
"""Prepend an `uint32` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Uint32Flags, x)
|
|
|
|
def PrependUint64(self, x):
|
|
"""Prepend an `uint64` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Uint64Flags, x)
|
|
|
|
def PrependInt8(self, x):
|
|
"""Prepend an `int8` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Int8Flags, x)
|
|
|
|
def PrependInt16(self, x):
|
|
"""Prepend an `int16` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Int16Flags, x)
|
|
|
|
def PrependInt32(self, x):
|
|
"""Prepend an `int32` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Int32Flags, x)
|
|
|
|
def PrependInt64(self, x):
|
|
"""Prepend an `int64` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Int64Flags, x)
|
|
|
|
def PrependFloat32(self, x):
|
|
"""Prepend a `float32` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Float32Flags, x)
|
|
|
|
def PrependFloat64(self, x):
|
|
"""Prepend a `float64` to the Builder buffer.
|
|
|
|
Note: aligns and checks for space.
|
|
"""
|
|
self.Prepend(N.Float64Flags, x)
|
|
|
|
def ForceDefaults(self, forceDefaults):
|
|
"""
|
|
In order to save space, fields that are set to their default value
|
|
don't get serialized into the buffer. Forcing defaults provides a
|
|
way to manually disable this optimization. When set to `True`, will
|
|
always serialize default values.
|
|
"""
|
|
self.forceDefaults = forceDefaults
|
|
|
|
##############################################################
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def PrependVOffsetT(self, x): self.Prepend(N.VOffsetTFlags, x)
|
|
|
|
def Place(self, x, flags):
|
|
"""
|
|
Place prepends a value specified by `flags` to the Builder,
|
|
without checking for available space.
|
|
"""
|
|
|
|
N.enforce_number(x, flags)
|
|
self.head = self.head - flags.bytewidth
|
|
encode.Write(flags.packer_type, self.Bytes, self.Head(), x)
|
|
|
|
def PlaceVOffsetT(self, x):
|
|
"""PlaceVOffsetT prepends a VOffsetT to the Builder, without checking
|
|
for space.
|
|
"""
|
|
N.enforce_number(x, N.VOffsetTFlags)
|
|
self.head = self.head - N.VOffsetTFlags.bytewidth
|
|
encode.Write(packer.voffset, self.Bytes, self.Head(), x)
|
|
|
|
def PlaceSOffsetT(self, x):
|
|
"""PlaceSOffsetT prepends a SOffsetT to the Builder, without checking
|
|
for space.
|
|
"""
|
|
N.enforce_number(x, N.SOffsetTFlags)
|
|
self.head = self.head - N.SOffsetTFlags.bytewidth
|
|
encode.Write(packer.soffset, self.Bytes, self.Head(), x)
|
|
|
|
def PlaceUOffsetT(self, x):
|
|
"""PlaceUOffsetT prepends a UOffsetT to the Builder, without checking
|
|
for space.
|
|
"""
|
|
N.enforce_number(x, N.UOffsetTFlags)
|
|
self.head = self.head - N.UOffsetTFlags.bytewidth
|
|
encode.Write(packer.uoffset, self.Bytes, self.Head(), x)
|
|
## @endcond
|
|
|
|
## @cond FLATBUFFERS_INTERNAL
|
|
def vtableEqual(a, objectStart, b):
|
|
"""vtableEqual compares an unwritten vtable to a written vtable."""
|
|
|
|
N.enforce_number(objectStart, N.UOffsetTFlags)
|
|
|
|
if len(a) * N.VOffsetTFlags.bytewidth != len(b):
|
|
return False
|
|
|
|
for i, elem in enumerate(a):
|
|
x = encode.Get(packer.voffset, b, i * N.VOffsetTFlags.bytewidth)
|
|
|
|
# Skip vtable entries that indicate a default value.
|
|
if x == 0 and elem == 0:
|
|
pass
|
|
else:
|
|
y = objectStart - elem
|
|
if x != y:
|
|
return False
|
|
return True
|
|
## @endcond
|
|
## @}
|