forked from BigfootDev/flatbuffers
f622e5996c
It's slightly faster to convert the value to signed value in PHP as
opposed to use pack and unpack.
For 1M get operation the difference is:
getShort in 3.3272678852081 seconds
getInt in 3.8338589668274 seconds
getLong in 5.6381590366364 seconds
getLong (neg) in 5.6149101257324 seconds
vs
getShort in 2.7564418315887 seconds
getInt in 3.1612701416016 seconds
getLong in 3.1369340419769 seconds
getLong (neg) in 3.1478710174561 seconds
And since pack("P") and unpack("q") has been removed now ByteBuffer
works for PHP >= 5.4
489 lines
12 KiB
PHP
489 lines
12 KiB
PHP
<?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.
|
|
*/
|
|
|
|
namespace Google\FlatBuffers;
|
|
|
|
class ByteBuffer
|
|
{
|
|
/**
|
|
* @var string $_buffer;
|
|
*/
|
|
public $_buffer;
|
|
|
|
/**
|
|
* @var int $_pos;
|
|
*/
|
|
private $_pos;
|
|
|
|
/**
|
|
* @var bool $_is_little_endian
|
|
*/
|
|
private static $_is_little_endian = null;
|
|
|
|
public static function wrap($bytes)
|
|
{
|
|
$bb = new ByteBuffer(0);
|
|
$bb->_buffer = $bytes;
|
|
|
|
return $bb;
|
|
}
|
|
|
|
/**
|
|
* @param $size
|
|
*/
|
|
public function __construct($size)
|
|
{
|
|
$this->_buffer = str_repeat("\0", $size);
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function capacity()
|
|
{
|
|
return strlen($this->_buffer);
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getPosition()
|
|
{
|
|
return $this->_pos;
|
|
}
|
|
|
|
/**
|
|
* @param $pos
|
|
*/
|
|
public function setPosition($pos)
|
|
{
|
|
$this->_pos = $pos;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function reset()
|
|
{
|
|
$this->_pos = 0;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function length()
|
|
{
|
|
return strlen($this->_buffer);
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function data()
|
|
{
|
|
return substr($this->_buffer, $this->_pos);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public static function isLittleEndian()
|
|
{
|
|
if (ByteBuffer::$_is_little_endian === null) {
|
|
ByteBuffer::$_is_little_endian = unpack('S', "\x01\x00")[1] === 1;
|
|
}
|
|
|
|
return ByteBuffer::$_is_little_endian;
|
|
}
|
|
|
|
/**
|
|
* write little endian value to the buffer.
|
|
*
|
|
* @param $offset
|
|
* @param $count byte length
|
|
* @param $data actual values
|
|
*/
|
|
public function writeLittleEndian($offset, $count, $data)
|
|
{
|
|
if (ByteBuffer::isLittleEndian()) {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$this->_buffer[$offset + $i] = chr($data >> $i * 8);
|
|
}
|
|
} else {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$this->_buffer[$offset + $count - 1 - $i] = chr($data >> $i * 8);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* read little endian value from the buffer
|
|
*
|
|
* @param $offset
|
|
* @param $count acutal size
|
|
* @return int
|
|
*/
|
|
public function readLittleEndian($offset, $count, $force_bigendian = false)
|
|
{
|
|
$this->assertOffsetAndLength($offset, $count);
|
|
$r = 0;
|
|
|
|
if (ByteBuffer::isLittleEndian() && $force_bigendian == false) {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$r |= ord($this->_buffer[$offset + $i]) << $i * 8;
|
|
}
|
|
} else {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$r |= ord($this->_buffer[$offset + $count -1 - $i]) << $i * 8;
|
|
}
|
|
}
|
|
|
|
return $r;
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $length
|
|
*/
|
|
public function assertOffsetAndLength($offset, $length)
|
|
{
|
|
if ($offset < 0 ||
|
|
$offset >= strlen($this->_buffer) ||
|
|
$offset + $length > strlen($this->_buffer)) {
|
|
throw new \OutOfRangeException(sprintf("offset: %d, length: %d, buffer; %d", $offset, $length, strlen($this->_buffer)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
* @return mixed
|
|
*/
|
|
public function putSbyte($offset, $value)
|
|
{
|
|
self::validateValue(-128, 127, $value, "sbyte");
|
|
|
|
$length = strlen($value);
|
|
$this->assertOffsetAndLength($offset, $length);
|
|
return $this->_buffer[$offset] = $value;
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
* @return mixed
|
|
*/
|
|
public function putByte($offset, $value)
|
|
{
|
|
self::validateValue(0, 255, $value, "byte");
|
|
|
|
$length = strlen($value);
|
|
$this->assertOffsetAndLength($offset, $length);
|
|
return $this->_buffer[$offset] = $value;
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function put($offset, $value)
|
|
{
|
|
$length = strlen($value);
|
|
$this->assertOffsetAndLength($offset, $length);
|
|
for ($i = 0; $i < $length; $i++) {
|
|
$this->_buffer[$offset + $i] = $value[$i];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putShort($offset, $value)
|
|
{
|
|
self::validateValue(-32768, 32767, $value, "short");
|
|
|
|
$this->assertOffsetAndLength($offset, 2);
|
|
$this->writeLittleEndian($offset, 2, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putUshort($offset, $value)
|
|
{
|
|
self::validateValue(0, 65535, $value, "short");
|
|
|
|
$this->assertOffsetAndLength($offset, 2);
|
|
$this->writeLittleEndian($offset, 2, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putInt($offset, $value)
|
|
{
|
|
// 2147483647 = (1 << 31) -1 = Maximum signed 32-bit int
|
|
// -2147483648 = -1 << 31 = Minimum signed 32-bit int
|
|
self::validateValue(-2147483648, 2147483647, $value, "int");
|
|
|
|
$this->assertOffsetAndLength($offset, 4);
|
|
$this->writeLittleEndian($offset, 4, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putUint($offset, $value)
|
|
{
|
|
// NOTE: We can't put big integer value. this is PHP limitation.
|
|
// 4294967295 = (1 << 32) -1 = Maximum unsigned 32-bin int
|
|
self::validateValue(0, 4294967295, $value, "uint", " php has big numbers limitation. check your PHP_INT_MAX");
|
|
|
|
$this->assertOffsetAndLength($offset, 4);
|
|
$this->writeLittleEndian($offset, 4, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putLong($offset, $value)
|
|
{
|
|
// NOTE: We can't put big integer value. this is PHP limitation.
|
|
self::validateValue(~PHP_INT_MAX, PHP_INT_MAX, $value, "long", " php has big numbers limitation. check your PHP_INT_MAX");
|
|
|
|
$this->assertOffsetAndLength($offset, 8);
|
|
$this->writeLittleEndian($offset, 8, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putUlong($offset, $value)
|
|
{
|
|
// NOTE: We can't put big integer value. this is PHP limitation.
|
|
self::validateValue(0, PHP_INT_MAX, $value, "long", " php has big numbers limitation. check your PHP_INT_MAX");
|
|
|
|
$this->assertOffsetAndLength($offset, 8);
|
|
$this->writeLittleEndian($offset, 8, $value);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putFloat($offset, $value)
|
|
{
|
|
$this->assertOffsetAndLength($offset, 4);
|
|
|
|
$floathelper = pack("f", $value);
|
|
$v = unpack("V", $floathelper);
|
|
$this->writeLittleEndian($offset, 4, $v[1]);
|
|
}
|
|
|
|
/**
|
|
* @param $offset
|
|
* @param $value
|
|
*/
|
|
public function putDouble($offset, $value)
|
|
{
|
|
$this->assertOffsetAndLength($offset, 8);
|
|
|
|
$floathelper = pack("d", $value);
|
|
$v = unpack("V*", $floathelper);
|
|
|
|
$this->writeLittleEndian($offset, 4, $v[1]);
|
|
$this->writeLittleEndian($offset + 4, 4, $v[2]);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return mixed
|
|
*/
|
|
public function getByte($index)
|
|
{
|
|
return ord($this->_buffer[$index]);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return mixed
|
|
*/
|
|
public function getSbyte($index)
|
|
{
|
|
$v = unpack("c", $this->_buffer[$index]);
|
|
return $v[1];
|
|
}
|
|
|
|
/**
|
|
* @param $buffer
|
|
*/
|
|
public function getX(&$buffer)
|
|
{
|
|
for ($i = $this->_pos, $j = 0; $j < strlen($buffer); $i++, $j++) {
|
|
$buffer[$j] = $this->_buffer[$i];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return mixed
|
|
*/
|
|
public function get($index)
|
|
{
|
|
$this->assertOffsetAndLength($index, 1);
|
|
return $this->_buffer[$index];
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $index
|
|
* @return mixed
|
|
*/
|
|
public function getBool($index)
|
|
{
|
|
return (bool)ord($this->_buffer[$index]);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getShort($index)
|
|
{
|
|
$result = $this->readLittleEndian($index, 2);
|
|
|
|
$sign = $index + (ByteBuffer::isLittleEndian() ? 1 : 0);
|
|
$issigned = isset($this->_buffer[$sign]) && ord($this->_buffer[$sign]) & 0x80;
|
|
|
|
// 65536 = 1 << 16 = Maximum unsigned 16-bit int
|
|
return $issigned ? $result - 65536 : $result;
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getUShort($index)
|
|
{
|
|
return $this->readLittleEndian($index, 2);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getInt($index)
|
|
{
|
|
$result = $this->readLittleEndian($index, 4);
|
|
|
|
$sign = $index + (ByteBuffer::isLittleEndian() ? 3 : 0);
|
|
$issigned = isset($this->_buffer[$sign]) && ord($this->_buffer[$sign]) & 0x80;
|
|
|
|
// 4294967296 = 1 << 32 = Maximum unsigned 32-bit int
|
|
return $issigned ? $result - 4294967296 : $result;
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getUint($index)
|
|
{
|
|
return $this->readLittleEndian($index, 4);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getLong($index)
|
|
{
|
|
return $this->readLittleEndian($index, 8);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return int
|
|
*/
|
|
public function getUlong($index)
|
|
{
|
|
return $this->readLittleEndian($index, 8);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return mixed
|
|
*/
|
|
public function getFloat($index)
|
|
{
|
|
$i = $this->readLittleEndian($index, 4);
|
|
|
|
return self::convertHelper(self::__FLOAT, $i);
|
|
}
|
|
|
|
/**
|
|
* @param $index
|
|
* @return float
|
|
*/
|
|
public function getDouble($index)
|
|
{
|
|
$i = $this->readLittleEndian($index, 4);
|
|
$i2 = $this->readLittleEndian($index + 4, 4);
|
|
|
|
return self::convertHelper(self::__DOUBLE, $i, $i2);
|
|
}
|
|
|
|
const __SHORT = 1;
|
|
const __INT = 2;
|
|
const __LONG = 3;
|
|
const __FLOAT = 4;
|
|
const __DOUBLE = 5;
|
|
private static function convertHelper($type, $value, $value2 = null) {
|
|
// readLittleEndian construct unsigned integer value from bytes. we have to encode this value to
|
|
// correct bytes, and decode as expected types with `unpack` function.
|
|
// then it returns correct type value.
|
|
// see also: http://php.net/manual/en/function.pack.php
|
|
|
|
switch ($type) {
|
|
case self::__FLOAT:
|
|
$inthelper = pack("V", $value);
|
|
$v = unpack("f", $inthelper);
|
|
return $v[1];
|
|
break;
|
|
case self::__DOUBLE:
|
|
$inthelper = pack("VV", $value, $value2);
|
|
$v = unpack("d", $inthelper);
|
|
return $v[1];
|
|
break;
|
|
default:
|
|
throw new \Exception(sprintf("unexpected type %d specified", $type));
|
|
}
|
|
}
|
|
|
|
private static function validateValue($min, $max, $value, $type, $additional_notes = "") {
|
|
if(!($min <= $value && $value <= $max)) {
|
|
throw new \InvalidArgumentException(sprintf("bad number %s for type %s.%s", $value, $type, $additional_notes));
|
|
}
|
|
}
|
|
}
|