src/Apache/Ignite/Internal/Binary/MessageBuffer.php - ignite-php-thin-client - Git at Google

 <?php
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 Apache\Ignite\Internal\Binary;

 use Apache\Ignite\Type\ObjectType;
 use Brick\Math\BigInteger;

 class MessageBuffer
 {
     const BYTE_ZERO = 0;
     const BYTE_ONE = 1;
     const BUFFER_CAPACITY_DEFAULT = 256;

     const PROTOCOL_STRING_ENCODING = 'UTF-8';

     private $buffer;
     private $position;
     private $length;

     private static $isLittleEndian;
     private static $defaultEncoding;

     public static function init(): void
     {
         MessageBuffer::$isLittleEndian = pack('L', 1) === pack('V', 1);
         MessageBuffer::$defaultEncoding = ini_get('default_charset');
     }

     public function __construct(int $capacity = MessageBuffer::BUFFER_CAPACITY_DEFAULT)
     {
         $this->buffer = '';
         $this->position = 0;
         $this->length = 0;
         $this->ensureCapacity($capacity);
     }

     public function getLength(): int
     {
         return $this->length;
     }

     public function getBuffer(): string
     {
         return $this->getSlice(0, $this->getLength());
     }

     public function getSlice(int $startPos, int $length): string
     {
         return substr($this->buffer, $startPos, $length);
     }

     public function getPosition(): int
     {
         return $this->position;
     }

     public function setPosition(int $position): void
     {
         $this->ensureCapacity($position);
         $this->position = $position;
     }

     public function append(string &$buffer): void
     {
         $this->buffer .= $buffer;
         $this->length += strlen($buffer);
     }

     public function writeByte(int $value, $signed = true): void
     {
         $this->writeNumber($value, ObjectType::BYTE, $signed);
     }

     public function writeShort(int $value): void
     {
         $this->writeNumber($value, ObjectType::SHORT);
     }

     public function writeInteger(int $value): void
     {
         $this->writeNumber($value, ObjectType::INTEGER);
     }

     public function writeLong(float $value): void
     {
         $this->writeNumber($value, ObjectType::LONG);
     }

     public function writeFloat(float $value): void
     {
         $this->writeNumber($value, ObjectType::FLOAT);
     }

     public function writeDouble(float $value): void
     {
         $this->writeNumber($value, ObjectType::DOUBLE);
     }

     public function writeNumber($value, int $type, bool $signed = true): void
     {
         $size = TypeInfo::getTypeInfo($type)->getSize();
         if ($type === ObjectType::LONG && BinaryUtils::$is32BitInt) {
             // pack longs doesn't work on 32-bit versions of PHP
             $strValue = strrev(hex2bin(BinaryUtils::getLongHex(BigInteger::of(abs($value)), $value < 0)));
         } else {
             $format = $this->getNumberFormat($type, $signed);
             $strValue = pack($format, $value);
             $this->convertEndianness($strValue, $type);
         }
         if (strlen($strValue) !== $size) {
             BinaryUtils::unsupportedType(BinaryUtils::getTypeName($type));
         }
         $this->writeStr($strValue);
     }

     public function writeBoolean(bool $value): void
     {
         $this->writeByte($value ? MessageBuffer::BYTE_ONE : MessageBuffer::BYTE_ZERO);
     }

     public function writeChar(string $value): void
     {
         $this->writeShort(mb_ord($value));
     }

     public function writeString(string $value, bool $encode = true): void
     {
         if ($encode) {
             $value = mb_convert_encoding($value, self::PROTOCOL_STRING_ENCODING, self::$defaultEncoding);
         }
         $length = strlen($value);
         $this->writeInteger($length);
         if ($length > 0) {
             $this->writeStr($value);
         }
     }

     public function writeBuffer(MessageBuffer $buffer, int $startPos, int $length): void
     {
         $this->writeStr($buffer->buffer, $startPos, $length);
     }

     public function readByte(bool $signed = true): int
     {
         return $this->readNumber(ObjectType::BYTE, $signed);
     }

     public function readShort(): int
     {
         return $this->readNumber(ObjectType::SHORT);
     }

     public function readInteger(): int
     {
         return $this->readNumber(ObjectType::INTEGER);
     }

     public function readLong(): float
     {
         return $this->readNumber(ObjectType::LONG);
     }

     public function readFloat(): float
     {
         return $this->readNumber(ObjectType::FLOAT);
     }

     public function readDouble(): float
     {
         return $this->readNumber(ObjectType::DOUBLE);
     }

     public function readNumber(int $type, bool $signed = true)
     {
         $size = BinaryUtils::getSize($type);
         $this->ensureSize($size);
         $strValue = substr($this->buffer, $this->position, $size);
         if ($type === ObjectType::LONG && BinaryUtils::$is32BitInt) {
             // unpack longs doesn't work on 32-bit versions of PHP
             $binValue = strrev($strValue);
             $isNegative = ord($binValue[0]) & 0x80;
             $hexValue = bin2hex($binValue);
             $bigIntValue = BigInteger::parse($hexValue, 16);
             if ($isNegative) {
                 $bigIntValue = BigInteger::parse(str_pad('1', $size * 2 + 1, '0'), 16)->minus($bigIntValue);
             }
             $value = $bigIntValue->toFloat();
             if ($isNegative) {
                 $value = -$value;
             }
         } else {
             $this->convertEndianness($strValue, $type);
             $value = unpack($this->getNumberFormat($type, $signed), $strValue);
             $value = $value[1];
         }
         $this->position += $size;
         return $value;
     }

     public function readBoolean(): bool
     {
         return $this->readByte() === MessageBuffer::BYTE_ONE;
     }

     public function readChar(): string
     {
         return mb_chr($this->readShort());
     }

     public function readString(bool $decode = true): string
     {
         $bytesCount = $this->readInteger();
         $this->ensureSize($bytesCount);
         $result = substr($this->buffer, $this->position, $bytesCount);
         if ($decode) {
             $result = mb_convert_encoding($result, self::$defaultEncoding, self::PROTOCOL_STRING_ENCODING);
         }
         $this->position += $bytesCount;
         return $result;
     }

     private function getNumberFormat(int $type, bool $signed): string
     {
         switch ($type) {
             case ObjectType::BYTE:
                 return $signed ? 'c' : 'C';
             case ObjectType::SHORT:
                 return $signed ? 's' : 'S';
             case ObjectType::INTEGER:
                 return $signed ? 'l' : 'L';
             case ObjectType::LONG:
                 return $signed ? 'q' : 'Q';
             case ObjectType::FLOAT:
                 return 'g';
             case ObjectType::DOUBLE:
                 return 'e';
             default:
                 BinaryUtils::internalError();
         }
         return null;
     }

     private function convertEndianness(string &$value, int $type): void
     {
         if (!MessageBuffer::$isLittleEndian &&
             ($type === ObjectType::SHORT ||
              $type === ObjectType::INTEGER ||
              $type === ObjectType::LONG)) {
             $value = strrev($value);
         }
     }

     private function writeStr(string &$buffer, int $startPos = 0, int $length = -1): void
     {
         if ($length < 0) {
             $length = strlen($buffer);
         }
         $this->ensureCapacity($length);
         for ($i = 0; $i < $length; $i++) {
             $this->buffer[$this->position + $i] = $buffer[$startPos + $i];
         }
         if ($this->position + $length > $this->length) {
             $this->length = $this->position + $length;
         }
         $this->position += $length;
     }

     private function ensureCapacity(int $size): void
     {
         if ($size <= 0) {
             return;
         }
         $capacity = strlen($this->buffer);
         $newCapacity = $capacity > 0 ? $capacity : $size;
         while ($this->position + $size > $newCapacity) {
             $newCapacity = $newCapacity * 2;
         }
         if ($capacity < $newCapacity) {
             $this->buffer .= str_repeat('0', $newCapacity - $capacity);
         }
     }

     private function ensureSize(int $size): void
     {
         if ($this->position + $size > $this->getLength()) {
             BinaryUtils::internalError('Unexpected format of response');
         }
     }
 }

 MessageBuffer::init();
	<?php
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 Apache\Ignite\Internal\Binary;

	use Apache\Ignite\Type\ObjectType;
	use Brick\Math\BigInteger;

	class MessageBuffer
	{
	const BYTE_ZERO = 0;
	const BYTE_ONE = 1;
	const BUFFER_CAPACITY_DEFAULT = 256;

	const PROTOCOL_STRING_ENCODING = 'UTF-8';

	private $buffer;
	private $position;
	private $length;

	private static $isLittleEndian;
	private static $defaultEncoding;

	public static function init(): void
	{
	MessageBuffer::$isLittleEndian = pack('L', 1) === pack('V', 1);
	MessageBuffer::$defaultEncoding = ini_get('default_charset');
	}

	public function __construct(int $capacity = MessageBuffer::BUFFER_CAPACITY_DEFAULT)
	{
	$this->buffer = '';
	$this->position = 0;
	$this->length = 0;
	$this->ensureCapacity($capacity);
	}

	public function getLength(): int
	{
	return $this->length;
	}

	public function getBuffer(): string
	{
	return $this->getSlice(0, $this->getLength());
	}

	public function getSlice(int $startPos, int $length): string
	{
	return substr($this->buffer, $startPos, $length);
	}

	public function getPosition(): int
	{
	return $this->position;
	}

	public function setPosition(int $position): void
	{
	$this->ensureCapacity($position);
	$this->position = $position;
	}

	public function append(string &$buffer): void
	{
	$this->buffer .= $buffer;
	$this->length += strlen($buffer);
	}

	public function writeByte(int $value, $signed = true): void
	{
	$this->writeNumber($value, ObjectType::BYTE, $signed);
	}

	public function writeShort(int $value): void
	{
	$this->writeNumber($value, ObjectType::SHORT);
	}

	public function writeInteger(int $value): void
	{
	$this->writeNumber($value, ObjectType::INTEGER);
	}

	public function writeLong(float $value): void
	{
	$this->writeNumber($value, ObjectType::LONG);
	}

	public function writeFloat(float $value): void
	{
	$this->writeNumber($value, ObjectType::FLOAT);
	}

	public function writeDouble(float $value): void
	{
	$this->writeNumber($value, ObjectType::DOUBLE);
	}

	public function writeNumber($value, int $type, bool $signed = true): void
	{
	$size = TypeInfo::getTypeInfo($type)->getSize();
	if ($type === ObjectType::LONG && BinaryUtils::$is32BitInt) {
	// pack longs doesn't work on 32-bit versions of PHP
	$strValue = strrev(hex2bin(BinaryUtils::getLongHex(BigInteger::of(abs($value)), $value < 0)));
	} else {
	$format = $this->getNumberFormat($type, $signed);
	$strValue = pack($format, $value);
	$this->convertEndianness($strValue, $type);
	}
	if (strlen($strValue) !== $size) {
	BinaryUtils::unsupportedType(BinaryUtils::getTypeName($type));
	}
	$this->writeStr($strValue);
	}

	public function writeBoolean(bool $value): void
	{
	$this->writeByte($value ? MessageBuffer::BYTE_ONE : MessageBuffer::BYTE_ZERO);
	}

	public function writeChar(string $value): void
	{
	$this->writeShort(mb_ord($value));
	}

	public function writeString(string $value, bool $encode = true): void
	{
	if ($encode) {
	$value = mb_convert_encoding($value, self::PROTOCOL_STRING_ENCODING, self::$defaultEncoding);
	}
	$length = strlen($value);
	$this->writeInteger($length);
	if ($length > 0) {
	$this->writeStr($value);
	}
	}

	public function writeBuffer(MessageBuffer $buffer, int $startPos, int $length): void
	{
	$this->writeStr($buffer->buffer, $startPos, $length);
	}

	public function readByte(bool $signed = true): int
	{
	return $this->readNumber(ObjectType::BYTE, $signed);
	}

	public function readShort(): int
	{
	return $this->readNumber(ObjectType::SHORT);
	}

	public function readInteger(): int
	{
	return $this->readNumber(ObjectType::INTEGER);
	}

	public function readLong(): float
	{
	return $this->readNumber(ObjectType::LONG);
	}

	public function readFloat(): float
	{
	return $this->readNumber(ObjectType::FLOAT);
	}

	public function readDouble(): float
	{
	return $this->readNumber(ObjectType::DOUBLE);
	}

	public function readNumber(int $type, bool $signed = true)
	{
	$size = BinaryUtils::getSize($type);
	$this->ensureSize($size);
	$strValue = substr($this->buffer, $this->position, $size);
	if ($type === ObjectType::LONG && BinaryUtils::$is32BitInt) {
	// unpack longs doesn't work on 32-bit versions of PHP
	$binValue = strrev($strValue);
	$isNegative = ord($binValue[0]) & 0x80;
	$hexValue = bin2hex($binValue);
	$bigIntValue = BigInteger::parse($hexValue, 16);
	if ($isNegative) {
	$bigIntValue = BigInteger::parse(str_pad('1', $size * 2 + 1, '0'), 16)->minus($bigIntValue);
	}
	$value = $bigIntValue->toFloat();
	if ($isNegative) {
	$value = -$value;
	}
	} else {
	$this->convertEndianness($strValue, $type);
	$value = unpack($this->getNumberFormat($type, $signed), $strValue);
	$value = $value[1];
	}
	$this->position += $size;
	return $value;
	}

	public function readBoolean(): bool
	{
	return $this->readByte() === MessageBuffer::BYTE_ONE;
	}

	public function readChar(): string
	{
	return mb_chr($this->readShort());
	}

	public function readString(bool $decode = true): string
	{
	$bytesCount = $this->readInteger();
	$this->ensureSize($bytesCount);
	$result = substr($this->buffer, $this->position, $bytesCount);
	if ($decode) {
	$result = mb_convert_encoding($result, self::$defaultEncoding, self::PROTOCOL_STRING_ENCODING);
	}
	$this->position += $bytesCount;
	return $result;
	}

	private function getNumberFormat(int $type, bool $signed): string
	{
	switch ($type) {
	case ObjectType::BYTE:
	return $signed ? 'c' : 'C';
	case ObjectType::SHORT:
	return $signed ? 's' : 'S';
	case ObjectType::INTEGER:
	return $signed ? 'l' : 'L';
	case ObjectType::LONG:
	return $signed ? 'q' : 'Q';
	case ObjectType::FLOAT:
	return 'g';
	case ObjectType::DOUBLE:
	return 'e';
	default:
	BinaryUtils::internalError();
	}
	return null;
	}

	private function convertEndianness(string &$value, int $type): void
	{
	if (!MessageBuffer::$isLittleEndian &&
	($type === ObjectType::SHORT \|\|
	$type === ObjectType::INTEGER \|\|
	$type === ObjectType::LONG)) {
	$value = strrev($value);
	}
	}

	private function writeStr(string &$buffer, int $startPos = 0, int $length = -1): void
	{
	if ($length < 0) {
	$length = strlen($buffer);
	}
	$this->ensureCapacity($length);
	for ($i = 0; $i < $length; $i++) {
	$this->buffer[$this->position + $i] = $buffer[$startPos + $i];
	}
	if ($this->position + $length > $this->length) {
	$this->length = $this->position + $length;
	}
	$this->position += $length;
	}

	private function ensureCapacity(int $size): void
	{
	if ($size <= 0) {
	return;
	}
	$capacity = strlen($this->buffer);
	$newCapacity = $capacity > 0 ? $capacity : $size;
	while ($this->position + $size > $newCapacity) {
	$newCapacity = $newCapacity * 2;
	}
	if ($capacity < $newCapacity) {
	$this->buffer .= str_repeat('0', $newCapacity - $capacity);
	}
	}

	private function ensureSize(int $size): void
	{
	if ($this->position + $size > $this->getLength()) {
	BinaryUtils::internalError('Unexpected format of response');
	}
	}
	}

	MessageBuffer::init();