<?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;

if (PHP_INT_SIZE > 4) {

// 4294967296 = 1 << 32 = Maximum unsigned 32-bit int

return $issigned ? $result - 4294967296 : $result;

} else {

// 32bit / Windows treated number as signed integer.

return $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));

}

}

}