| <?php |
| /* |
| * Copyright 2015 Google Inc. |
| * |
| * 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. |
| */ |
| |
| /// @file |
| /// @addtogroup flatbuffers_php_api |
| /// @{ |
| |
| namespace Google\FlatBuffers; |
| |
| class FlatbufferBuilder |
| { |
| /** |
| * Internal ByteBuffer for the FlatBuffer data. |
| * @var ByteBuffer $bb |
| */ |
| public $bb; |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * @var int $space |
| */ |
| protected $space; |
| |
| /** |
| * @var int $minalign |
| */ |
| protected $minalign = 1; |
| |
| /** |
| * @var array $vtable |
| */ |
| protected $vtable; |
| |
| /** |
| * @var int $vtable_in_use |
| */ |
| protected $vtable_in_use = 0; |
| |
| /** |
| * @var bool $nested |
| */ |
| protected $nested = false; |
| |
| /** |
| * @var int $object_start |
| */ |
| protected $object_start; |
| |
| /** |
| * @var array $vtables |
| */ |
| protected $vtables = array(); |
| |
| /** |
| * @var int $num_vtables |
| */ |
| protected $num_vtables = 0; |
| |
| /** |
| * @var int $vector_num_elems |
| */ |
| protected $vector_num_elems = 0; |
| |
| /** |
| * @var bool $force_defaults |
| */ |
| protected $force_defaults = false; |
| /// @endcond |
| |
| /** |
| * Create a FlatBufferBuilder with a given initial size. |
| * |
| * @param $initial_size initial byte buffer size. |
| */ |
| public function __construct($initial_size) |
| { |
| if ($initial_size <= 0) { |
| $initial_size = 1; |
| } |
| $this->space = $initial_size; |
| $this->bb = $this->newByteBuffer($initial_size); |
| } |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * create new bytebuffer |
| * |
| * @param $size |
| * @return ByteBuffer |
| */ |
| private function newByteBuffer($size) |
| { |
| return new ByteBuffer($size); |
| } |
| |
| /** |
| * Returns the current ByteBuffer offset. |
| * |
| * @return int |
| */ |
| public function offset() |
| { |
| return $this->bb->capacity() - $this->space; |
| } |
| |
| /** |
| * padding buffer |
| * |
| * @param $byte_size |
| */ |
| public function pad($byte_size) |
| { |
| for ($i = 0; $i < $byte_size; $i++) { |
| $this->bb->putByte(--$this->space, "\0"); |
| } |
| } |
| |
| /** |
| * prepare bytebuffer |
| * |
| * @param $size |
| * @param $additional_bytes |
| * @throws \Exception |
| */ |
| public function prep($size, $additional_bytes) |
| { |
| if ($size > $this->minalign) { |
| $this->minalign = $size; |
| } |
| |
| $align_size = ((~($this->bb->capacity() - $this->space + $additional_bytes)) + 1) & ($size - 1); |
| while ($this->space < $align_size + $size + $additional_bytes) { |
| $old_buf_size = $this->bb->capacity(); |
| $this->bb = $this->growByteBuffer($this->bb); |
| $this->space += $this->bb->capacity() - $old_buf_size; |
| } |
| |
| $this->pad($align_size); |
| } |
| |
| /** |
| * @param ByteBuffer $bb |
| * @return ByteBuffer |
| * @throws \Exception |
| */ |
| private static function growByteBuffer(ByteBuffer $bb) |
| { |
| $old_buf_size = $bb->capacity(); |
| if (($old_buf_size & 0xC0000000) != 0) { |
| throw new \Exception("FlatBuffers: cannot grow buffer beyond 2 gigabytes"); |
| } |
| $new_buf_size = $old_buf_size << 1; |
| |
| $bb->setPosition(0); |
| $nbb = new ByteBuffer($new_buf_size); |
| |
| $nbb->setPosition($new_buf_size - $old_buf_size); |
| |
| // TODO(chobie): is this little bit faster? |
| //$nbb->_buffer = substr_replace($nbb->_buffer, $bb->_buffer, $new_buf_size - $old_buf_size, strlen($bb->_buffer)); |
| for ($i = $new_buf_size - $old_buf_size, $j = 0; $j < strlen($bb->_buffer); $i++, $j++) { |
| $nbb->_buffer[$i] = $bb->_buffer[$j]; |
| } |
| |
| return $nbb; |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putBool($x) |
| { |
| $this->bb->put($this->space -= 1, chr((int)(bool)($x))); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putByte($x) |
| { |
| $this->bb->put($this->space -= 1, chr($x)); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putSbyte($x) |
| { |
| $this->bb->put($this->space -= 1, chr($x)); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putShort($x) |
| { |
| $this->bb->putShort($this->space -= 2, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putUshort($x) |
| { |
| $this->bb->putUshort($this->space -= 2, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putInt($x) |
| { |
| $this->bb->putInt($this->space -= 4, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putUint($x) |
| { |
| if ($x > PHP_INT_MAX) { |
| throw new \InvalidArgumentException("your platform can't handle uint correctly. use 64bit machine."); |
| } |
| |
| $this->bb->putUint($this->space -= 4, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putLong($x) |
| { |
| if ($x > PHP_INT_MAX) { |
| throw new \InvalidArgumentException("Your platform can't handle long correctly. Use a 64bit machine."); |
| } |
| |
| $this->bb->putLong($this->space -= 8, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putUlong($x) |
| { |
| if ($x > PHP_INT_MAX) { |
| throw new \InvalidArgumentException("Your platform can't handle ulong correctly. This is a php limitation. Please wait for the extension release."); |
| } |
| |
| $this->bb->putUlong($this->space -= 8, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putFloat($x) |
| { |
| $this->bb->putFloat($this->space -= 4, $x); |
| } |
| |
| /** |
| * @param $x |
| */ |
| public function putDouble($x) |
| { |
| $this->bb->putDouble($this->space -= 8, $x); |
| } |
| /// @endcond |
| |
| /** |
| * Add a `bool` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `bool` to add to the buffer. |
| */ |
| public function addBool($x) |
| { |
| $this->prep(1, 0); |
| $this->putBool($x); |
| } |
| |
| /** |
| * Add a `byte` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `byte` to add to the buffer. |
| */ |
| public function addByte($x) |
| { |
| $this->prep(1, 0); |
| $this->putByte($x); |
| } |
| |
| /** |
| * Add a `signed byte` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `signed byte` to add to the buffer. |
| */ |
| public function addSbyte($x) |
| { |
| $this->prep(1, 0); |
| $this->putSbyte($x); |
| } |
| |
| /** |
| * Add a `short` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `short` to add to the buffer. |
| */ |
| public function addShort($x) |
| { |
| $this->prep(2, 0); |
| $this->putShort($x); |
| } |
| |
| /** |
| * Add an `unsigned short` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `unsigned short` to add to the buffer. |
| */ |
| public function addUshort($x) |
| { |
| $this->prep(2, 0); |
| $this->putUshort($x); |
| } |
| |
| /** |
| * Add an `int` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `int` to add to the buffer. |
| */ |
| public function addInt($x) |
| { |
| $this->prep(4, 0); |
| $this->putInt($x); |
| } |
| |
| /** |
| * Add an `unsigned int` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `unsigned int` to add to the buffer. |
| */ |
| public function addUint($x) |
| { |
| $this->prep(4, 0); |
| $this->putUint($x); |
| } |
| |
| /** |
| * Add a `long` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `long` to add to the buffer. |
| */ |
| public function addLong($x) |
| { |
| $this->prep(8, 0); |
| $this->putLong($x); |
| } |
| |
| /** |
| * Add an `unsigned long` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `unsigned long` to add to the buffer. |
| */ |
| public function addUlong($x) |
| { |
| $this->prep(8, 0); |
| $this->putUlong($x); |
| } |
| |
| /** |
| * Add a `float` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `float` to add to the buffer. |
| */ |
| public function addFloat($x) |
| { |
| $this->prep(4, 0); |
| $this->putFloat($x); |
| } |
| |
| /** |
| * Add a `double` to the buffer, properly aligned, and grows the buffer (if necessary). |
| * @param $x The `double` to add to the buffer. |
| */ |
| public function addDouble($x) |
| { |
| $this->prep(8, 0); |
| $this->putDouble($x); |
| } |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addBoolX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addBool($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addByteX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addByte($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addSbyteX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addSbyte($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addShortX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addShort($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addUshortX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addUshort($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addIntX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addInt($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addUintX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addUint($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addLongX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addLong($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addUlongX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addUlong($x); |
| $this->slot($o); |
| } |
| } |
| |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addFloatX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addFloat($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| */ |
| public function addDoubleX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addDouble($x); |
| $this->slot($o); |
| } |
| } |
| |
| /** |
| * @param $o |
| * @param $x |
| * @param $d |
| * @throws \Exception |
| */ |
| public function addOffsetX($o, $x, $d) |
| { |
| if ($this->force_defaults || $x != $d) { |
| $this->addOffset($x); |
| $this->slot($o); |
| } |
| } |
| /// @endcond |
| |
| /** |
| * Adds on offset, relative to where it will be written. |
| * @param $off The offset to add to the buffer. |
| * @throws \Exception Throws an exception if `$off` is greater than the underlying ByteBuffer's |
| * offest. |
| */ |
| public function addOffset($off) |
| { |
| $this->prep(Constants::SIZEOF_INT, 0); // Ensure alignment is already done |
| if ($off > $this->offset()) { |
| throw new \Exception(""); |
| } |
| |
| $off = $this->offset() - $off + Constants::SIZEOF_INT; |
| $this->putInt($off); |
| } |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * @param $elem_size |
| * @param $num_elems |
| * @param $alignment |
| * @throws \Exception |
| */ |
| public function startVector($elem_size, $num_elems, $alignment) |
| { |
| $this->notNested(); |
| $this->vector_num_elems = $num_elems; |
| $this->prep(Constants::SIZEOF_INT, $elem_size * $num_elems); |
| $this->prep($alignment, $elem_size * $num_elems); // Just in case alignemnt > int; |
| } |
| |
| /** |
| * @return int |
| */ |
| public function endVector() |
| { |
| $this->putUint($this->vector_num_elems); |
| return $this->offset(); |
| } |
| |
| protected function is_utf8($bytes) |
| { |
| if (function_exists('mb_detect_encoding')) { |
| return (bool) mb_detect_encoding($bytes, 'UTF-8', true); |
| } |
| |
| $len = strlen($bytes); |
| if ($len < 1) { |
| /* NOTE: always return 1 when passed string is null */ |
| return true; |
| } |
| |
| for ($j = 0, $i = 0; $i < $len; $i++) { |
| // check ACII |
| if ($bytes[$j] == "\x09" || |
| $bytes[$j] == "\x0A" || |
| $bytes[$j] == "\x0D" || |
| ($bytes[$j] >= "\x20" && $bytes[$j] <= "\x7E")) { |
| $j++; |
| continue; |
| } |
| |
| /* non-overlong 2-byte */ |
| if ((($i+1) <= $len) && |
| ($bytes[$j] >= "\xC2" && $bytes[$j] <= "\xDF" && |
| ($bytes[$j+1] >= "\x80" && $bytes[$j+1] <= "\xBF"))) { |
| $j += 2; |
| $i++; |
| continue; |
| } |
| |
| /* excluding overlongs */ |
| if ((($i + 2) <= $len) && |
| $bytes[$j] == "\xE0" && |
| ($bytes[$j+1] >= "\xA0" && $bytes[$j+1] <= "\xBF" && |
| ($bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF"))) { |
| $bytes += 3; |
| $i +=2; |
| continue; |
| } |
| |
| /* straight 3-byte */ |
| if ((($i+2) <= $len) && |
| (($bytes[$j] >= "\xE1" && $bytes[$j] <= "\xEC") || |
| $bytes[$j] == "\xEE" || |
| $bytes[$j] = "\xEF") && |
| ($bytes[$j+1] >= "\x80" && $bytes[$j+1] <= "\xBF") && |
| ($bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF")) { |
| $j += 3; |
| $i += 2; |
| continue; |
| } |
| |
| /* excluding surrogates */ |
| if ((($i+2) <= $len) && |
| $bytes[$j] == "\xED" && |
| ($bytes[$j+1] >= "\x80" && $bytes[$j+1] <= "\x9f" && |
| ($bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF"))) { |
| $j += 3; |
| $i += 2; |
| continue; |
| } |
| |
| /* planes 1-3 */ |
| if ((($i + 3) <= $len) && |
| $bytes[$j] == "\xF0" && |
| ($bytes[$j+1] >= "\x90" && $bytes[$j+1] <= "\xBF") && |
| ($bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF") && |
| ($bytes[$j+3] >= "\x80" && $bytes[$j+3] <= "\xBF")) { |
| $j += 4; |
| $i += 3; |
| continue; |
| } |
| |
| |
| /* planes 4-15 */ |
| if ((($i+3) <= $len) && |
| $bytes[$j] >= "\xF1" && $bytes[$j] <= "\xF3" && |
| $bytes[$j+1] >= "\x80" && $bytes[$j+1] <= "\xBF" && |
| $bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF" && |
| $bytes[$j+3] >= "\x80" && $bytes[$j+3] <= "\xBF" |
| ) { |
| $j += 4; |
| $i += 3; |
| continue; |
| } |
| |
| /* plane 16 */ |
| if ((($i+3) <= $len) && |
| $bytes[$j] == "\xF4" && |
| ($bytes[$j+1] >= "\x80" && $bytes[$j+1] <= "\x8F") && |
| ($bytes[$j+2] >= "\x80" && $bytes[$j+2] <= "\xBF") && |
| ($bytes[$j+3] >= "\x80" && $bytes[$j+3] <= "\xBF") |
| ) { |
| $bytes += 4; |
| $i += 3; |
| continue; |
| } |
| |
| |
| return false; |
| } |
| |
| return true; |
| } |
| /// @endcond |
| |
| /** |
| * Encode the string `$s` in the buffer using UTF-8. |
| * @param string $s The string to encode. |
| * @return int The offset in the buffer where the encoded string starts. |
| * @throws InvalidArgumentException Thrown if the input string `$s` is not |
| * UTF-8. |
| */ |
| public function createString($s) |
| { |
| if (!$this->is_utf8($s)) { |
| throw new \InvalidArgumentException("string must be utf-8 encoded value."); |
| } |
| |
| $this->notNested(); |
| $this->addByte(0); // null terminated |
| $this->startVector(1, strlen($s), 1); |
| $this->space -= strlen($s); |
| for ($i = $this->space, $j = 0 ; $j < strlen($s) ; $i++, $j++) { |
| $this->bb->_buffer[$i] = $s[$j]; |
| } |
| return $this->endVector(); |
| } |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * @throws \Exception |
| */ |
| public function notNested() |
| { |
| if ($this->nested) { |
| throw new \Exception("FlatBuffers; object serialization must not be nested"); |
| } |
| } |
| |
| /** |
| * @param $obj |
| * @throws \Exception |
| */ |
| public function nested($obj) |
| { |
| if ($obj != $this->offset()) { |
| throw new \Exception("FlatBuffers: struct must be serialized inline"); |
| } |
| } |
| |
| /** |
| * @param $numfields |
| * @throws \Exception |
| */ |
| public function startObject($numfields) |
| { |
| $this->notNested(); |
| if ($this->vtable == null || count($this->vtable) < $numfields) { |
| $this->vtable = array(); |
| } |
| |
| $this->vtable_in_use = $numfields; |
| for ($i = 0; $i < $numfields; $i++) { |
| $this->vtable[$i] = 0; |
| } |
| |
| $this->nested = true; |
| $this->object_start = $this->offset(); |
| } |
| |
| /** |
| * @param $voffset |
| * @param $x |
| * @param $d |
| * @throws \Exception |
| */ |
| public function addStructX($voffset, $x, $d) |
| { |
| if ($x != $d) { |
| $this->nested($x); |
| $this->slot($voffset); |
| } |
| } |
| |
| /** |
| * @param $voffset |
| * @param $x |
| * @param $d |
| * @throws \Exception |
| */ |
| public function addStruct($voffset, $x, $d) |
| { |
| if ($x != $d) { |
| $this->nested($x); |
| $this->slot($voffset); |
| } |
| } |
| |
| /** |
| * @param $voffset |
| */ |
| public function slot($voffset) |
| { |
| $this->vtable[$voffset] = $this->offset(); |
| } |
| |
| /** |
| * @return int |
| * @throws \Exception |
| */ |
| public function endObject() |
| { |
| if ($this->vtable == null || !$this->nested) { |
| throw new \Exception("FlatBuffers: endObject called without startObject"); |
| } |
| |
| $this->addInt(0); |
| $vtableloc = $this->offset(); |
| |
| for ($i = $this->vtable_in_use -1; $i >= 0; $i--) { |
| $off = ($this->vtable[$i] != 0) ? $vtableloc - $this->vtable[$i] : 0; |
| $this->addShort($off); |
| } |
| |
| $standard_fields = 2; // the fields below |
| $this->addShort($vtableloc - $this->object_start); |
| $this->addShort(($this->vtable_in_use + $standard_fields) * Constants::SIZEOF_SHORT); |
| |
| // search for an existing vtable that matches the current one. |
| $existing_vtable = 0; |
| |
| for ($i = 0; $i < $this->num_vtables; $i++) { |
| $vt1 = $this->bb->capacity() - $this->vtables[$i]; |
| $vt2 = $this->space; |
| |
| $len = $this->bb->getShort($vt1); |
| |
| if ($len == $this->bb->getShort($vt2)) { |
| for ($j = Constants::SIZEOF_SHORT; $j < $len; $j += Constants::SIZEOF_SHORT) { |
| if ($this->bb->getShort($vt1 + $j) != $this->bb->getShort($vt2 + $j)) { |
| continue 2; |
| } |
| } |
| $existing_vtable = $this->vtables[$i]; |
| break; |
| } |
| } |
| |
| if ($existing_vtable != 0) { |
| // Found a match: |
| // Remove the current vtable |
| $this->space = $this->bb->capacity() - $vtableloc; |
| $this->bb->putInt($this->space, $existing_vtable - $vtableloc); |
| } else { |
| // No Match: |
| // Add the location of the current vtable to the list of vtables |
| if ($this->num_vtables == count($this->vtables)) { |
| $vtables = $this->vtables; |
| $this->vtables = array(); |
| // copy of |
| for ($i = 0; $i < count($vtables) * 2; $i++) { |
| $this->vtables[$i] = ($i < count($vtables)) ? $vtables[$i] : 0; |
| } |
| } |
| $this->vtables[$this->num_vtables++] = $this->offset(); |
| $this->bb->putInt($this->bb->capacity() - $vtableloc, $this->offset() - $vtableloc); |
| } |
| |
| $this->nested = false; |
| $this->vtable = null; |
| return $vtableloc; |
| } |
| |
| /** |
| * @param $table |
| * @param $field |
| * @throws \Exception |
| */ |
| public function required($table, $field) |
| { |
| $table_start = $this->bb->capacity() - $table; |
| $vtable_start = $table_start - $this->bb->getInt($table_start); |
| $ok = $this->bb->getShort($vtable_start + $field) != 0; |
| |
| if (!$ok) { |
| throw new \Exception("FlatBuffers: field " . $field . " must be set"); |
| } |
| } |
| /// @endcond |
| |
| /** |
| * Finalize a buffer, pointing to the given `$root_table`. |
| * @param $root_table An offest to be added to the buffer. |
| * @param $file_identifier A FlatBuffer file identifier to be added to the |
| * buffer before `$root_table`. This defaults to `null`. |
| * @throws InvalidArgumentException Thrown if an invalid `$identifier` is |
| * given, where its length is not equal to |
| * `Constants::FILE_IDENTIFIER_LENGTH`. |
| */ |
| public function finish($root_table, $identifier = null) |
| { |
| if ($identifier == null) { |
| $this->prep($this->minalign, Constants::SIZEOF_INT); |
| $this->addOffset($root_table); |
| $this->bb->setPosition($this->space); |
| } else { |
| $this->prep($this->minalign, Constants::SIZEOF_INT + Constants::FILE_IDENTIFIER_LENGTH); |
| if (strlen($identifier) != Constants::FILE_IDENTIFIER_LENGTH) { |
| throw new \InvalidArgumentException( |
| sprintf("FlatBuffers: file identifier must be length %d", |
| Constants::FILE_IDENTIFIER_LENGTH)); |
| } |
| |
| for ($i = Constants::FILE_IDENTIFIER_LENGTH - 1; $i >= 0; |
| $i--) { |
| $this->addByte(ord($identifier[$i])); |
| } |
| $this->finish($root_table); |
| } |
| } |
| |
| /** |
| * In order to save space, fields that are set to their default value don't |
| * get serialized into the buffer. |
| * @param bool $forceDefaults When set to `true`, always serializes default |
| * values. |
| */ |
| public function forceDefaults($forceDefaults) |
| { |
| $this->force_defaults = $forceDefaults; |
| } |
| |
| /** |
| * Get the ByteBuffer representing the FlatBuffer. |
| * @return ByteBuffer The ByteBuffer containing the FlatBuffer data. |
| */ |
| public function dataBuffer() |
| { |
| return $this->bb; |
| } |
| |
| /// @cond FLATBUFFERS_INTERNAL |
| /** |
| * @return int |
| */ |
| public function dataStart() |
| { |
| return $this->space; |
| } |
| /// @endcond |
| |
| /** |
| * Utility function to copy and return the FlatBuffer data from the |
| * underlying ByteBuffer. |
| * @return string A string (representing a byte[]) that contains a copy |
| * of the FlatBuffer data. |
| */ |
| public function sizedByteArray() |
| { |
| $start = $this->space; |
| $length = $this->bb->capacity() - $this->space; |
| |
| $result = str_repeat("\0", $length); |
| $this->bb->setPosition($start); |
| $this->bb->getX($result); |
| |
| return $result; |
| } |
| } |
| |
| /// @} |