* Look up a field in the vtable, return an offset into the object, or 0 if the * field is not present.

Get retrieves a value of the type specified by `flags` at the given offset.

* Get the buffer's position.

Read a byte from data. @param index position of the element in ReadBuf @return a byte

Offset provides access into the Table's vtable. Fields which are deprecated are ignored by checking against the vtable's length.

Associates a key with a value. All subsequent calls to operator+=, where the specified key is contained in {{ and }} delimiters will be replaced by t

* Start a new array/vector of objects. Users usually will not call * this directly. The FlatBuffers compiler will create a start/end * method f

Returns an index set to the end. Note: Indexing this will result in an out of bounds error.

* Get the start of data of a vector whose offset is stored at "offset" in this object.

<summary> Adds an offset, relative to where it will be written. </summary> <param name="off">The offset to add to the buffer.</param>

StartVector initializes bookkeeping for writing a new vector. A vector has the following format: <UOffsetT: number of elements in this vector> <T:

EndVector writes data necessary to finish vector construction.

* Get the length of a vector whose offset is stored at "offset" in this object.

Returns true if the vector is empty. This just provides another standardized method that is expected of vectors.

A helper function to print out if an assertion failed.

* Finish off the creation of an array and all its elements. The array must be * created with `startVector`. * * @returns The offset at which

Read a 32-bit int from data. @param index position of the element in ReadBuf @return an int

CreateString writes a null-terminated string as a vector.

* Returns element as [Byte]. For vector types, it will return size of the vector. For String * type, it will be parsed as integer. Unsigned element

* A helper function for generating list for obj api

* Retrieve the relative offset stored at "offset"

* A helper function for generating list for obj api * @param listAccessor function that accepts an index and return data at that index * @param

Put an array of bytes into the buffer at {@code writePosition()}. Write position will be incremented. @param value the data to be copied @param start

Look up a field in the vtable. @param vtable_offset An `int` offset to the vtable in the Table's ByteBuffer. @return Returns an offset into the objec

@brief Get the serialized buffer (after you call `Finish()`). @return Returns an `uint8_t` pointer to the FlatBuffer data inside the buffer.

StartObject initializes bookkeeping for writing a new object.

* Prepare 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 le

@brief The current size of the serialized buffer, counting from the end. @return Returns an `SizeT` with the current size of the buffer.

* Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed * instead of a string, it is assumed to contain valid UTF-8 encoded da

Finish finalizes a buffer, pointing to the given `rootTable`.

* Create a JavaScript string from UTF-8 data stored inside the FlatBuffer. * This allocates a new string and converts to wide chars upon each acces

PrependUOffsetTRelativeSlot prepends an UOffsetT onto the object at vtable slot `o`. If value `x` equals default `d`, then the slot will be s

* Create a Java `String` from UTF-8 data stored inside the FlatBuffer. * * This allocates a new string and converts to wide chars upon each acce

Since we're generating schema and corresponding data in tandem, this convenience function adds strings to both at once.

EndObject writes data necessary to finish object construction.

* Set the buffer's position.

* @return int */

* Get the underlying `Uint8Array`.

* A helper function to pack a list of object * * @returns list of offsets of each non null/undefined object

Expose ReadBuf as an array of bytes. This method is meant to be as efficient as possible, so for a array-backed ReadBuf, it should return its own inte

* Returns element as [Int]. For vector types, it will return size of the vector. For String type, * it will type to be parsed as integer. Unsigned

Vector retrieves the start of data of the vector whose offset is stored at "off" in this object.

Write a 32-bit into in the buffer at {@code writePosition()}. Write position will be incremented.

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 len

<summary> Verify table object using generated verification function. </summary> <param name="tablePos"> Position in the Table</param> <param name="off

Start encoding a new object in the buffer. Users will not usually need to call this directly. The `FlatBuffers` compiler will generate helper methods

Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within. <p>This method exists primarily to allow recycling Table

Read a 64-bit long from data. @param index position of the element in ReadBuf @return a long