php/ByteBuffer.php - third_party/flatbuffers - Git at Google

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