summaryrefslogtreecommitdiff
path: root/vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php')
-rw-r--r--vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php453
1 files changed, 453 insertions, 0 deletions
diff --git a/vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php b/vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php
new file mode 100644
index 000000000..cda5c0d4c
--- /dev/null
+++ b/vendor/packaged/thrift/src/Protocol/TBinaryProtocol.php
@@ -0,0 +1,453 @@
+<?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.
+ *
+ * @package thrift.protocol
+ */
+
+namespace Thrift\Protocol;
+
+use Thrift\Type\TType;
+use Thrift\Exception\TProtocolException;
+use Thrift\Factory\TStringFuncFactory;
+
+/**
+ * Binary implementation of the Thrift protocol.
+ *
+ */
+class TBinaryProtocol extends TProtocol
+{
+ const VERSION_MASK = 0xffff0000;
+ const VERSION_1 = 0x80010000;
+
+ protected $strictRead_ = false;
+ protected $strictWrite_ = true;
+
+ public function __construct($trans, $strictRead = false, $strictWrite = true)
+ {
+ parent::__construct($trans);
+ $this->strictRead_ = $strictRead;
+ $this->strictWrite_ = $strictWrite;
+ }
+
+ public function writeMessageBegin($name, $type, $seqid)
+ {
+ if ($this->strictWrite_) {
+ $version = self::VERSION_1 | $type;
+
+ return
+ $this->writeI32($version) +
+ $this->writeString($name) +
+ $this->writeI32($seqid);
+ } else {
+ return
+ $this->writeString($name) +
+ $this->writeByte($type) +
+ $this->writeI32($seqid);
+ }
+ }
+
+ public function writeMessageEnd()
+ {
+ return 0;
+ }
+
+ public function writeStructBegin($name)
+ {
+ return 0;
+ }
+
+ public function writeStructEnd()
+ {
+ return 0;
+ }
+
+ public function writeFieldBegin($fieldName, $fieldType, $fieldId)
+ {
+ return
+ $this->writeByte($fieldType) +
+ $this->writeI16($fieldId);
+ }
+
+ public function writeFieldEnd()
+ {
+ return 0;
+ }
+
+ public function writeFieldStop()
+ {
+ return
+ $this->writeByte(TType::STOP);
+ }
+
+ public function writeMapBegin($keyType, $valType, $size)
+ {
+ return
+ $this->writeByte($keyType) +
+ $this->writeByte($valType) +
+ $this->writeI32($size);
+ }
+
+ public function writeMapEnd()
+ {
+ return 0;
+ }
+
+ public function writeListBegin($elemType, $size)
+ {
+ return
+ $this->writeByte($elemType) +
+ $this->writeI32($size);
+ }
+
+ public function writeListEnd()
+ {
+ return 0;
+ }
+
+ public function writeSetBegin($elemType, $size)
+ {
+ return
+ $this->writeByte($elemType) +
+ $this->writeI32($size);
+ }
+
+ public function writeSetEnd()
+ {
+ return 0;
+ }
+
+ public function writeBool($value)
+ {
+ $data = pack('c', $value ? 1 : 0);
+ $this->trans_->write($data, 1);
+
+ return 1;
+ }
+
+ public function writeByte($value)
+ {
+ $data = pack('c', $value);
+ $this->trans_->write($data, 1);
+
+ return 1;
+ }
+
+ public function writeI16($value)
+ {
+ $data = pack('n', $value);
+ $this->trans_->write($data, 2);
+
+ return 2;
+ }
+
+ public function writeI32($value)
+ {
+ $data = pack('N', $value);
+ $this->trans_->write($data, 4);
+
+ return 4;
+ }
+
+ public function writeI64($value)
+ {
+ // If we are on a 32bit architecture we have to explicitly deal with
+ // 64-bit twos-complement arithmetic since PHP wants to treat all ints
+ // as signed and any int over 2^31 - 1 as a float
+ if (PHP_INT_SIZE == 4) {
+ $neg = $value < 0;
+
+ if ($neg) {
+ $value *= -1;
+ }
+
+ $hi = (int)($value / 4294967296);
+ $lo = (int)$value;
+
+ if ($neg) {
+ $hi = ~$hi;
+ $lo = ~$lo;
+ if (($lo & (int)0xffffffff) == (int)0xffffffff) {
+ $lo = 0;
+ $hi++;
+ } else {
+ $lo++;
+ }
+ }
+ $data = pack('N2', $hi, $lo);
+ } else {
+ $hi = $value >> 32;
+ $lo = $value & 0xFFFFFFFF;
+ $data = pack('N2', $hi, $lo);
+ }
+
+ $this->trans_->write($data, 8);
+
+ return 8;
+ }
+
+ public function writeDouble($value)
+ {
+ $data = pack('d', $value);
+ $this->trans_->write(strrev($data), 8);
+
+ return 8;
+ }
+
+ public function writeString($value)
+ {
+ $len = TStringFuncFactory::create()->strlen($value);
+ $result = $this->writeI32($len);
+ if ($len) {
+ $this->trans_->write($value, $len);
+ }
+
+ return $result + $len;
+ }
+
+ public function readMessageBegin(&$name, &$type, &$seqid)
+ {
+ $result = $this->readI32($sz);
+ if ($sz < 0) {
+ $version = (int)($sz & self::VERSION_MASK);
+ if ($version != (int)self::VERSION_1) {
+ throw new TProtocolException('Bad version identifier: ' . $sz, TProtocolException::BAD_VERSION);
+ }
+ $type = $sz & 0x000000ff;
+ $result +=
+ $this->readString($name) +
+ $this->readI32($seqid);
+ } else {
+ if ($this->strictRead_) {
+ throw new TProtocolException(
+ 'No version identifier, old protocol client?',
+ TProtocolException::BAD_VERSION
+ );
+ } else {
+ // Handle pre-versioned input
+ $name = $this->trans_->readAll($sz);
+ $result +=
+ $sz +
+ $this->readByte($type) +
+ $this->readI32($seqid);
+ }
+ }
+
+ return $result;
+ }
+
+ public function readMessageEnd()
+ {
+ return 0;
+ }
+
+ public function readStructBegin(&$name)
+ {
+ $name = '';
+
+ return 0;
+ }
+
+ public function readStructEnd()
+ {
+ return 0;
+ }
+
+ public function readFieldBegin(&$name, &$fieldType, &$fieldId)
+ {
+ $result = $this->readByte($fieldType);
+ if ($fieldType == TType::STOP) {
+ $fieldId = 0;
+
+ return $result;
+ }
+ $result += $this->readI16($fieldId);
+
+ return $result;
+ }
+
+ public function readFieldEnd()
+ {
+ return 0;
+ }
+
+ public function readMapBegin(&$keyType, &$valType, &$size)
+ {
+ return
+ $this->readByte($keyType) +
+ $this->readByte($valType) +
+ $this->readI32($size);
+ }
+
+ public function readMapEnd()
+ {
+ return 0;
+ }
+
+ public function readListBegin(&$elemType, &$size)
+ {
+ return
+ $this->readByte($elemType) +
+ $this->readI32($size);
+ }
+
+ public function readListEnd()
+ {
+ return 0;
+ }
+
+ public function readSetBegin(&$elemType, &$size)
+ {
+ return
+ $this->readByte($elemType) +
+ $this->readI32($size);
+ }
+
+ public function readSetEnd()
+ {
+ return 0;
+ }
+
+ public function readBool(&$value)
+ {
+ $data = $this->trans_->readAll(1);
+ $arr = unpack('c', $data);
+ $value = $arr[1] == 1;
+
+ return 1;
+ }
+
+ public function readByte(&$value)
+ {
+ $data = $this->trans_->readAll(1);
+ $arr = unpack('c', $data);
+ $value = $arr[1];
+
+ return 1;
+ }
+
+ public function readI16(&$value)
+ {
+ $data = $this->trans_->readAll(2);
+ $arr = unpack('n', $data);
+ $value = $arr[1];
+ if ($value > 0x7fff) {
+ $value = 0 - (($value - 1) ^ 0xffff);
+ }
+
+ return 2;
+ }
+
+ public function readI32(&$value)
+ {
+ $data = $this->trans_->readAll(4);
+ $arr = unpack('N', $data);
+ $value = $arr[1];
+ if ($value > 0x7fffffff) {
+ $value = 0 - (($value - 1) ^ 0xffffffff);
+ }
+
+ return 4;
+ }
+
+ public function readI64(&$value)
+ {
+ $data = $this->trans_->readAll(8);
+
+ $arr = unpack('N2', $data);
+
+ // If we are on a 32bit architecture we have to explicitly deal with
+ // 64-bit twos-complement arithmetic since PHP wants to treat all ints
+ // as signed and any int over 2^31 - 1 as a float
+ if (PHP_INT_SIZE == 4) {
+ $hi = $arr[1];
+ $lo = $arr[2];
+ $isNeg = $hi < 0;
+
+ // Check for a negative
+ if ($isNeg) {
+ $hi = ~$hi & (int)0xffffffff;
+ $lo = ~$lo & (int)0xffffffff;
+
+ if ($lo == (int)0xffffffff) {
+ $hi++;
+ $lo = 0;
+ } else {
+ $lo++;
+ }
+ }
+
+ // Force 32bit words in excess of 2G to pe positive - we deal wigh sign
+ // explicitly below
+
+ if ($hi & (int)0x80000000) {
+ $hi &= (int)0x7fffffff;
+ $hi += 0x80000000;
+ }
+
+ if ($lo & (int)0x80000000) {
+ $lo &= (int)0x7fffffff;
+ $lo += 0x80000000;
+ }
+
+ $value = $hi * 4294967296 + $lo;
+
+ if ($isNeg) {
+ $value = 0 - $value;
+ }
+ } else {
+ // Upcast negatives in LSB bit
+ if ($arr[2] & 0x80000000) {
+ $arr[2] = $arr[2] & 0xffffffff;
+ }
+
+ // Check for a negative
+ if ($arr[1] & 0x80000000) {
+ $arr[1] = $arr[1] & 0xffffffff;
+ $arr[1] = $arr[1] ^ 0xffffffff;
+ $arr[2] = $arr[2] ^ 0xffffffff;
+ $value = 0 - $arr[1] * 4294967296 - $arr[2] - 1;
+ } else {
+ $value = $arr[1] * 4294967296 + $arr[2];
+ }
+ }
+
+ return 8;
+ }
+
+ public function readDouble(&$value)
+ {
+ $data = strrev($this->trans_->readAll(8));
+ $arr = unpack('d', $data);
+ $value = $arr[1];
+
+ return 8;
+ }
+
+ public function readString(&$value)
+ {
+ $result = $this->readI32($len);
+ if ($len) {
+ $value = $this->trans_->readAll($len);
+ } else {
+ $value = '';
+ }
+
+ return $result + $len;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-28 03:42:18 +0000