lib/php/lib/Protocol/TCompactProtocol.php - packaging/sources/thrift - Gitiles

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

 /**
  * Compact implementation of the Thrift protocol.
  *
  */
 class TCompactProtocol extends TProtocol
 {
     const COMPACT_STOP = 0x00;
     const COMPACT_TRUE = 0x01;
     const COMPACT_FALSE = 0x02;
     const COMPACT_BYTE = 0x03;
     const COMPACT_I16 = 0x04;
     const COMPACT_I32 = 0x05;
     const COMPACT_I64 = 0x06;
     const COMPACT_DOUBLE = 0x07;
     const COMPACT_BINARY = 0x08;
     const COMPACT_LIST = 0x09;
     const COMPACT_SET = 0x0A;
     const COMPACT_MAP = 0x0B;
     const COMPACT_STRUCT = 0x0C;

     const STATE_CLEAR = 0;
     const STATE_FIELD_WRITE = 1;
     const STATE_VALUE_WRITE = 2;
     const STATE_CONTAINER_WRITE = 3;
     const STATE_BOOL_WRITE = 4;
     const STATE_FIELD_READ = 5;
     const STATE_CONTAINER_READ = 6;
     const STATE_VALUE_READ = 7;
     const STATE_BOOL_READ = 8;

     const VERSION_MASK = 0x1f;
     const VERSION = 1;
     const PROTOCOL_ID = 0x82;
     const TYPE_MASK = 0xe0;
     const TYPE_BITS = 0x07;
     const TYPE_SHIFT_AMOUNT = 5;

     protected static $ctypes = array(
         TType::STOP => TCompactProtocol::COMPACT_STOP,
         TType::BOOL => TCompactProtocol::COMPACT_TRUE, // used for collection
         TType::BYTE => TCompactProtocol::COMPACT_BYTE,
         TType::I16 => TCompactProtocol::COMPACT_I16,
         TType::I32 => TCompactProtocol::COMPACT_I32,
         TType::I64 => TCompactProtocol::COMPACT_I64,
         TType::DOUBLE => TCompactProtocol::COMPACT_DOUBLE,
         TType::STRING => TCompactProtocol::COMPACT_BINARY,
         TType::STRUCT => TCompactProtocol::COMPACT_STRUCT,
         TType::LST => TCompactProtocol::COMPACT_LIST,
         TType::SET => TCompactProtocol::COMPACT_SET,
         TType::MAP => TCompactProtocol::COMPACT_MAP,
     );

     protected static $ttypes = array(
         TCompactProtocol::COMPACT_STOP => TType::STOP,
         TCompactProtocol::COMPACT_TRUE => TType::BOOL, // used for collection
         TCompactProtocol::COMPACT_FALSE => TType::BOOL,
         TCompactProtocol::COMPACT_BYTE => TType::BYTE,
         TCompactProtocol::COMPACT_I16 => TType::I16,
         TCompactProtocol::COMPACT_I32 => TType::I32,
         TCompactProtocol::COMPACT_I64 => TType::I64,
         TCompactProtocol::COMPACT_DOUBLE => TType::DOUBLE,
         TCompactProtocol::COMPACT_BINARY => TType::STRING,
         TCompactProtocol::COMPACT_STRUCT => TType::STRUCT,
         TCompactProtocol::COMPACT_LIST => TType::LST,
         TCompactProtocol::COMPACT_SET => TType::SET,
         TCompactProtocol::COMPACT_MAP => TType::MAP,
     );

     protected $state = TCompactProtocol::STATE_CLEAR;
     protected $lastFid = 0;
     protected $boolFid = null;
     protected $boolValue = null;
     protected $structs = array();
     protected $containers = array();

     // Some varint / zigzag helper methods
     public function toZigZag($n, $bits)
     {
         return ($n << 1) ^ ($n >> ($bits - 1));
     }

     public function fromZigZag($n)
     {
         return ($n >> 1) ^ -($n & 1);
     }

     public function getVarint($data)
     {
         $out = "";
         while (true) {
             if (($data & ~0x7f) === 0) {
                 $out .= chr($data);
                 break;
             } else {
                 $out .= chr(($data & 0xff) | 0x80);
                 $data = $data >> 7;
             }
         }

         return $out;
     }

     public function writeVarint($data)
     {
         $out = $this->getVarint($data);
         $result = TStringFuncFactory::create()->strlen($out);
         $this->trans_->write($out, $result);

         return $result;
     }

     public function readVarint(&$result)
     {
         $idx = 0;
         $shift = 0;
         $result = 0;
         while (true) {
             $x = $this->trans_->readAll(1);
             $arr = unpack('C', $x);
             $byte = $arr[1];
             $idx += 1;
             $result |= ($byte & 0x7f) << $shift;
             if (($byte >> 7) === 0) {
                 return $idx;
             }
             $shift += 7;
         }

         return $idx;
     }

     public function __construct($trans)
     {
         parent::__construct($trans);
     }

     public function writeMessageBegin($name, $type, $seqid)
     {
         $written =
             $this->writeUByte(TCompactProtocol::PROTOCOL_ID) +
             $this->writeUByte(TCompactProtocol::VERSION |
                 ($type << TCompactProtocol::TYPE_SHIFT_AMOUNT)) +
             $this->writeVarint($seqid) +
             $this->writeString($name);
         $this->state = TCompactProtocol::STATE_VALUE_WRITE;

         return $written;
     }

     public function writeMessageEnd()
     {
         $this->state = TCompactProtocol::STATE_CLEAR;

         return 0;
     }

     public function writeStructBegin($name)
     {
         $this->structs[] = array($this->state, $this->lastFid);
         $this->state = TCompactProtocol::STATE_FIELD_WRITE;
         $this->lastFid = 0;

         return 0;
     }

     public function writeStructEnd()
     {
         $old_values = array_pop($this->structs);
         $this->state = $old_values[0];
         $this->lastFid = $old_values[1];

         return 0;
     }

     public function writeFieldStop()
     {
         return $this->writeByte(0);
     }

     public function writeFieldHeader($type, $fid)
     {
         $written = 0;
         $delta = $fid - $this->lastFid;
         if (0 < $delta && $delta <= 15) {
             $written = $this->writeUByte(($delta << 4) | $type);
         } else {
             $written = $this->writeByte($type) +
                 $this->writeI16($fid);
         }
         $this->lastFid = $fid;

         return $written;
     }

     public function writeFieldBegin($field_name, $field_type, $field_id)
     {
         if ($field_type == TTYPE::BOOL) {
             $this->state = TCompactProtocol::STATE_BOOL_WRITE;
             $this->boolFid = $field_id;

             return 0;
         } else {
             $this->state = TCompactProtocol::STATE_VALUE_WRITE;

             return $this->writeFieldHeader(self::$ctypes[$field_type], $field_id);
         }
     }

     public function writeFieldEnd()
     {
         $this->state = TCompactProtocol::STATE_FIELD_WRITE;

         return 0;
     }

     public function writeCollectionBegin($etype, $size)
     {
         $written = 0;
         if ($size <= 14) {
             $written = $this->writeUByte($size << 4 |
                 self::$ctypes[$etype]);
         } else {
             $written = $this->writeUByte(0xf0 |
                     self::$ctypes[$etype]) +
                 $this->writeVarint($size);
         }
         $this->containers[] = $this->state;
         $this->state = TCompactProtocol::STATE_CONTAINER_WRITE;

         return $written;
     }

     public function writeMapBegin($key_type, $val_type, $size)
     {
         $written = 0;
         if ($size == 0) {
             $written = $this->writeByte(0);
         } else {
             $written = $this->writeVarint($size) +
                 $this->writeUByte(self::$ctypes[$key_type] << 4 |
                     self::$ctypes[$val_type]);
         }
         $this->containers[] = $this->state;

         return $written;
     }

     public function writeCollectionEnd()
     {
         $this->state = array_pop($this->containers);

         return 0;
     }

     public function writeMapEnd()
     {
         return $this->writeCollectionEnd();
     }

     public function writeListBegin($elem_type, $size)
     {
         return $this->writeCollectionBegin($elem_type, $size);
     }

     public function writeListEnd()
     {
         return $this->writeCollectionEnd();
     }

     public function writeSetBegin($elem_type, $size)
     {
         return $this->writeCollectionBegin($elem_type, $size);
     }

     public function writeSetEnd()
     {
         return $this->writeCollectionEnd();
     }

     public function writeBool($value)
     {
         if ($this->state == TCompactProtocol::STATE_BOOL_WRITE) {
             $ctype = TCompactProtocol::COMPACT_FALSE;
             if ($value) {
                 $ctype = TCompactProtocol::COMPACT_TRUE;
             }

             return $this->writeFieldHeader($ctype, $this->boolFid);
         } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_WRITE) {
             return $this->writeByte($value ? 1 : 0);
         } else {
             throw new TProtocolException('Invalid state in compact protocol');
         }
     }

     public function writeByte($value)
     {
         $data = pack('c', $value);
         $this->trans_->write($data, 1);

         return 1;
     }

     public function writeUByte($byte)
     {
         $this->trans_->write(pack('C', $byte), 1);

         return 1;
     }

     public function writeI16($value)
     {
         $thing = $this->toZigZag($value, 16);

         return $this->writeVarint($thing);
     }

     public function writeI32($value)
     {
         $thing = $this->toZigZag($value, 32);

         return $this->writeVarint($thing);
     }

     public function writeDouble($value)
     {
         $data = pack('d', $value);
         $this->trans_->write($data, 8);

         return 8;
     }

     public function writeString($value)
     {
         $len = TStringFuncFactory::create()->strlen($value);
         $result = $this->writeVarint($len);
         if ($len) {
             $this->trans_->write($value, $len);
         }

         return $result + $len;
     }

     public function readFieldBegin(&$name, &$field_type, &$field_id)
     {
         $result = $this->readUByte($compact_type_and_delta);

         $compact_type = $compact_type_and_delta & 0x0f;

         if ($compact_type == TType::STOP) {
             $field_type = $compact_type;
             $field_id = 0;

             return $result;
         }
         $delta = $compact_type_and_delta >> 4;
         if ($delta == 0) {
             $result += $this->readI16($field_id);
         } else {
             $field_id = $this->lastFid + $delta;
         }
         $this->lastFid = $field_id;
         $field_type = $this->getTType($compact_type);

         if ($compact_type == TCompactProtocol::COMPACT_TRUE) {
             $this->state = TCompactProtocol::STATE_BOOL_READ;
             $this->boolValue = true;
         } elseif ($compact_type == TCompactProtocol::COMPACT_FALSE) {
             $this->state = TCompactProtocol::STATE_BOOL_READ;
             $this->boolValue = false;
         } else {
             $this->state = TCompactProtocol::STATE_VALUE_READ;
         }

         return $result;
     }

     public function readFieldEnd()
     {
         $this->state = TCompactProtocol::STATE_FIELD_READ;

         return 0;
     }

     public function readUByte(&$value)
     {
         $data = $this->trans_->readAll(1);
         $arr = unpack('C', $data);
         $value = $arr[1];

         return 1;
     }

     public function readByte(&$value)
     {
         $data = $this->trans_->readAll(1);
         $arr = unpack('c', $data);
         $value = $arr[1];

         return 1;
     }

     public function readZigZag(&$value)
     {
         $result = $this->readVarint($value);
         $value = $this->fromZigZag($value);

         return $result;
     }

     public function readMessageBegin(&$name, &$type, &$seqid)
     {
         $protoId = 0;
         $result = $this->readUByte($protoId);
         if ($protoId != TCompactProtocol::PROTOCOL_ID) {
             throw new TProtocolException('Bad protocol id in TCompact message');
         }
         $verType = 0;
         $result += $this->readUByte($verType);
         $type = ($verType >> TCompactProtocol::TYPE_SHIFT_AMOUNT) & TCompactProtocol::TYPE_BITS;
         $version = $verType & TCompactProtocol::VERSION_MASK;
         if ($version != TCompactProtocol::VERSION) {
             throw new TProtocolException('Bad version in TCompact message');
         }
         $result += $this->readVarint($seqid);
         $result += $this->readString($name);

         return $result;
     }

     public function readMessageEnd()
     {
         return 0;
     }

     public function readStructBegin(&$name)
     {
         $name = ''; // unused
         $this->structs[] = array($this->state, $this->lastFid);
         $this->state = TCompactProtocol::STATE_FIELD_READ;
         $this->lastFid = 0;

         return 0;
     }

     public function readStructEnd()
     {
         $last = array_pop($this->structs);
         $this->state = $last[0];
         $this->lastFid = $last[1];

         return 0;
     }

     public function readCollectionBegin(&$type, &$size)
     {
         $sizeType = 0;
         $result = $this->readUByte($sizeType);
         $size = $sizeType >> 4;
         $type = $this->getTType($sizeType);
         if ($size == 15) {
             $result += $this->readVarint($size);
         }
         $this->containers[] = $this->state;
         $this->state = TCompactProtocol::STATE_CONTAINER_READ;

         return $result;
     }

     public function readMapBegin(&$key_type, &$val_type, &$size)
     {
         $result = $this->readVarint($size);
         $types = 0;
         if ($size > 0) {
             $result += $this->readUByte($types);
         }
         $val_type = $this->getTType($types);
         $key_type = $this->getTType($types >> 4);
         $this->containers[] = $this->state;
         $this->state = TCompactProtocol::STATE_CONTAINER_READ;

         return $result;
     }

     public function readCollectionEnd()
     {
         $this->state = array_pop($this->containers);

         return 0;
     }

     public function readMapEnd()
     {
         return $this->readCollectionEnd();
     }

     public function readListBegin(&$elem_type, &$size)
     {
         return $this->readCollectionBegin($elem_type, $size);
     }

     public function readListEnd()
     {
         return $this->readCollectionEnd();
     }

     public function readSetBegin(&$elem_type, &$size)
     {
         return $this->readCollectionBegin($elem_type, $size);
     }

     public function readSetEnd()
     {
         return $this->readCollectionEnd();
     }

     public function readBool(&$value)
     {
         if ($this->state == TCompactProtocol::STATE_BOOL_READ) {
             $value = $this->boolValue;

             return 0;
         } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_READ) {
             return $this->readByte($value);
         } else {
             throw new TProtocolException('Invalid state in compact protocol');
         }
     }

     public function readI16(&$value)
     {
         return $this->readZigZag($value);
     }

     public function readI32(&$value)
     {
         return $this->readZigZag($value);
     }

     public function readDouble(&$value)
     {
         $data = $this->trans_->readAll(8);
         $arr = unpack('d', $data);
         $value = $arr[1];

         return 8;
     }

     public function readString(&$value)
     {
         $result = $this->readVarint($len);
         if ($len) {
             $value = $this->trans_->readAll($len);
         } else {
             $value = '';
         }

         return $result + $len;
     }

     public function getTType($byte)
     {
         return self::$ttypes[$byte & 0x0f];
     }

     // 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

     // Read and write I64 as two 32 bit numbers $hi and $lo

     public function readI64(&$value)
     {
         // Read varint from wire
         $hi = 0;
         $lo = 0;

         $idx = 0;
         $shift = 0;

         while (true) {
             $x = $this->trans_->readAll(1);
             $arr = unpack('C', $x);
             $byte = $arr[1];
             $idx += 1;
             // Shift hi and lo together.
             if ($shift < 28) {
                 $lo |= (($byte & 0x7f) << $shift);
             } elseif ($shift == 28) {
                 $lo |= (($byte & 0x0f) << 28);
                 $hi |= (($byte & 0x70) >> 4);
             } else {
                 $hi |= (($byte & 0x7f) << ($shift - 32));
             }
             if (($byte >> 7) === 0) {
                 break;
             }
             $shift += 7;
         }

         // Now, unzig it.
         $xorer = 0;
         if ($lo & 1) {
             $xorer = 0xffffffff;
         }
         $lo = ($lo >> 1) & 0x7fffffff;
         $lo = $lo | (($hi & 1) << 31);
         $hi = ($hi >> 1) ^ $xorer;
         $lo = $lo ^ $xorer;

         // Now put $hi and $lo back together
         $isNeg = $hi < 0 || $hi & 0x80000000;

         // 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 be positive - we deal with sign
         // explicitly below

         if ($hi & (int)0x80000000) {
             $hi &= (int)0x7fffffff;
             $hi += 0x80000000;
         }

         if ($lo & (int)0x80000000) {
             $lo &= (int)0x7fffffff;
             $lo += 0x80000000;
         }

         // Create as negative value first, since we can store -2^63 but not 2^63
         $value = -$hi * 4294967296 - $lo;

         if (!$isNeg) {
             $value = -$value;
         }

         return $idx;
     }

     public function writeI64($value)
     {
         // If we are in an I32 range, use the easy method below.
         if (($value > 4294967296) || ($value < -4294967296)) {
             // Convert $value to $hi and $lo
             $neg = $value < 0;

             if ($neg) {
                 $value *= -1;
             }

             $hi = (int)$value >> 32;
             $lo = (int)$value & 0xffffffff;

             if ($neg) {
                 $hi = ~$hi;
                 $lo = ~$lo;
                 if (($lo & (int)0xffffffff) == (int)0xffffffff) {
                     $lo = 0;
                     $hi++;
                 } else {
                     $lo++;
                 }
             }

             // Now do the zigging and zagging.
             $xorer = 0;
             if ($neg) {
                 $xorer = 0xffffffff;
             }
             $lowbit = ($lo >> 31) & 1;
             $hi = ($hi << 1) | $lowbit;
             $lo = ($lo << 1);
             $lo = ($lo ^ $xorer) & 0xffffffff;
             $hi = ($hi ^ $xorer) & 0xffffffff;

             // now write out the varint, ensuring we shift both hi and lo
             $out = "";
             while (true) {
                 if (($lo & ~0x7f) === 0 &&
                     $hi === 0) {
                     $out .= chr($lo);
                     break;
                 } else {
                     $out .= chr(($lo & 0xff) | 0x80);
                     $lo = $lo >> 7;
                     $lo = $lo | ($hi << 25);
                     $hi = $hi >> 7;
                     // Right shift carries sign, but we don't want it to.
                     $hi = $hi & (127 << 25);
                 }
             }

             $ret = TStringFuncFactory::create()->strlen($out);
             $this->trans_->write($out, $ret);

             return $ret;
         } else {
             return $this->writeVarint($this->toZigZag($value, 64));
         }
     }
 }
	<?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;

	/**
	* Compact implementation of the Thrift protocol.
	*
	*/
	class TCompactProtocol extends TProtocol
	{
	const COMPACT_STOP = 0x00;
	const COMPACT_TRUE = 0x01;
	const COMPACT_FALSE = 0x02;
	const COMPACT_BYTE = 0x03;
	const COMPACT_I16 = 0x04;
	const COMPACT_I32 = 0x05;
	const COMPACT_I64 = 0x06;
	const COMPACT_DOUBLE = 0x07;
	const COMPACT_BINARY = 0x08;
	const COMPACT_LIST = 0x09;
	const COMPACT_SET = 0x0A;
	const COMPACT_MAP = 0x0B;
	const COMPACT_STRUCT = 0x0C;

	const STATE_CLEAR = 0;
	const STATE_FIELD_WRITE = 1;
	const STATE_VALUE_WRITE = 2;
	const STATE_CONTAINER_WRITE = 3;
	const STATE_BOOL_WRITE = 4;
	const STATE_FIELD_READ = 5;
	const STATE_CONTAINER_READ = 6;
	const STATE_VALUE_READ = 7;
	const STATE_BOOL_READ = 8;

	const VERSION_MASK = 0x1f;
	const VERSION = 1;
	const PROTOCOL_ID = 0x82;
	const TYPE_MASK = 0xe0;
	const TYPE_BITS = 0x07;
	const TYPE_SHIFT_AMOUNT = 5;

	protected static $ctypes = array(
	TType::STOP => TCompactProtocol::COMPACT_STOP,
	TType::BOOL => TCompactProtocol::COMPACT_TRUE, // used for collection
	TType::BYTE => TCompactProtocol::COMPACT_BYTE,
	TType::I16 => TCompactProtocol::COMPACT_I16,
	TType::I32 => TCompactProtocol::COMPACT_I32,
	TType::I64 => TCompactProtocol::COMPACT_I64,
	TType::DOUBLE => TCompactProtocol::COMPACT_DOUBLE,
	TType::STRING => TCompactProtocol::COMPACT_BINARY,
	TType::STRUCT => TCompactProtocol::COMPACT_STRUCT,
	TType::LST => TCompactProtocol::COMPACT_LIST,
	TType::SET => TCompactProtocol::COMPACT_SET,
	TType::MAP => TCompactProtocol::COMPACT_MAP,
	);

	protected static $ttypes = array(
	TCompactProtocol::COMPACT_STOP => TType::STOP,
	TCompactProtocol::COMPACT_TRUE => TType::BOOL, // used for collection
	TCompactProtocol::COMPACT_FALSE => TType::BOOL,
	TCompactProtocol::COMPACT_BYTE => TType::BYTE,
	TCompactProtocol::COMPACT_I16 => TType::I16,
	TCompactProtocol::COMPACT_I32 => TType::I32,
	TCompactProtocol::COMPACT_I64 => TType::I64,
	TCompactProtocol::COMPACT_DOUBLE => TType::DOUBLE,
	TCompactProtocol::COMPACT_BINARY => TType::STRING,
	TCompactProtocol::COMPACT_STRUCT => TType::STRUCT,
	TCompactProtocol::COMPACT_LIST => TType::LST,
	TCompactProtocol::COMPACT_SET => TType::SET,
	TCompactProtocol::COMPACT_MAP => TType::MAP,
	);

	protected $state = TCompactProtocol::STATE_CLEAR;
	protected $lastFid = 0;
	protected $boolFid = null;
	protected $boolValue = null;
	protected $structs = array();
	protected $containers = array();

	// Some varint / zigzag helper methods
	public function toZigZag($n, $bits)
	{
	return ($n << 1) ^ ($n >> ($bits - 1));
	}

	public function fromZigZag($n)
	{
	return ($n >> 1) ^ -($n & 1);
	}

	public function getVarint($data)
	{
	$out = "";
	while (true) {
	if (($data & ~0x7f) === 0) {
	$out .= chr($data);
	break;
	} else {
	$out .= chr(($data & 0xff) \| 0x80);
	$data = $data >> 7;
	}
	}

	return $out;
	}

	public function writeVarint($data)
	{
	$out = $this->getVarint($data);
	$result = TStringFuncFactory::create()->strlen($out);
	$this->trans_->write($out, $result);

	return $result;
	}

	public function readVarint(&$result)
	{
	$idx = 0;
	$shift = 0;
	$result = 0;
	while (true) {
	$x = $this->trans_->readAll(1);
	$arr = unpack('C', $x);
	$byte = $arr[1];
	$idx += 1;
	$result \|= ($byte & 0x7f) << $shift;
	if (($byte >> 7) === 0) {
	return $idx;
	}
	$shift += 7;
	}

	return $idx;
	}

	public function __construct($trans)
	{
	parent::__construct($trans);
	}

	public function writeMessageBegin($name, $type, $seqid)
	{
	$written =
	$this->writeUByte(TCompactProtocol::PROTOCOL_ID) +
	$this->writeUByte(TCompactProtocol::VERSION \|
	($type << TCompactProtocol::TYPE_SHIFT_AMOUNT)) +
	$this->writeVarint($seqid) +
	$this->writeString($name);
	$this->state = TCompactProtocol::STATE_VALUE_WRITE;

	return $written;
	}

	public function writeMessageEnd()
	{
	$this->state = TCompactProtocol::STATE_CLEAR;

	return 0;
	}

	public function writeStructBegin($name)
	{
	$this->structs[] = array($this->state, $this->lastFid);
	$this->state = TCompactProtocol::STATE_FIELD_WRITE;
	$this->lastFid = 0;

	return 0;
	}

	public function writeStructEnd()
	{
	$old_values = array_pop($this->structs);
	$this->state = $old_values[0];
	$this->lastFid = $old_values[1];

	return 0;
	}

	public function writeFieldStop()
	{
	return $this->writeByte(0);
	}

	public function writeFieldHeader($type, $fid)
	{
	$written = 0;
	$delta = $fid - $this->lastFid;
	if (0 < $delta && $delta <= 15) {
	$written = $this->writeUByte(($delta << 4) \| $type);
	} else {
	$written = $this->writeByte($type) +
	$this->writeI16($fid);
	}
	$this->lastFid = $fid;

	return $written;
	}

	public function writeFieldBegin($field_name, $field_type, $field_id)
	{
	if ($field_type == TTYPE::BOOL) {
	$this->state = TCompactProtocol::STATE_BOOL_WRITE;
	$this->boolFid = $field_id;

	return 0;
	} else {
	$this->state = TCompactProtocol::STATE_VALUE_WRITE;

	return $this->writeFieldHeader(self::$ctypes[$field_type], $field_id);
	}
	}

	public function writeFieldEnd()
	{
	$this->state = TCompactProtocol::STATE_FIELD_WRITE;

	return 0;
	}

	public function writeCollectionBegin($etype, $size)
	{
	$written = 0;
	if ($size <= 14) {
	$written = $this->writeUByte($size << 4 \|
	self::$ctypes[$etype]);
	} else {
	$written = $this->writeUByte(0xf0 \|
	self::$ctypes[$etype]) +
	$this->writeVarint($size);
	}
	$this->containers[] = $this->state;
	$this->state = TCompactProtocol::STATE_CONTAINER_WRITE;

	return $written;
	}

	public function writeMapBegin($key_type, $val_type, $size)
	{
	$written = 0;
	if ($size == 0) {
	$written = $this->writeByte(0);
	} else {
	$written = $this->writeVarint($size) +
	$this->writeUByte(self::$ctypes[$key_type] << 4 \|
	self::$ctypes[$val_type]);
	}
	$this->containers[] = $this->state;

	return $written;
	}

	public function writeCollectionEnd()
	{
	$this->state = array_pop($this->containers);

	return 0;
	}

	public function writeMapEnd()
	{
	return $this->writeCollectionEnd();
	}

	public function writeListBegin($elem_type, $size)
	{
	return $this->writeCollectionBegin($elem_type, $size);
	}

	public function writeListEnd()
	{
	return $this->writeCollectionEnd();
	}

	public function writeSetBegin($elem_type, $size)
	{
	return $this->writeCollectionBegin($elem_type, $size);
	}

	public function writeSetEnd()
	{
	return $this->writeCollectionEnd();
	}

	public function writeBool($value)
	{
	if ($this->state == TCompactProtocol::STATE_BOOL_WRITE) {
	$ctype = TCompactProtocol::COMPACT_FALSE;
	if ($value) {
	$ctype = TCompactProtocol::COMPACT_TRUE;
	}

	return $this->writeFieldHeader($ctype, $this->boolFid);
	} elseif ($this->state == TCompactProtocol::STATE_CONTAINER_WRITE) {
	return $this->writeByte($value ? 1 : 0);
	} else {
	throw new TProtocolException('Invalid state in compact protocol');
	}
	}

	public function writeByte($value)
	{
	$data = pack('c', $value);
	$this->trans_->write($data, 1);

	return 1;
	}

	public function writeUByte($byte)
	{
	$this->trans_->write(pack('C', $byte), 1);

	return 1;
	}

	public function writeI16($value)
	{
	$thing = $this->toZigZag($value, 16);

	return $this->writeVarint($thing);
	}

	public function writeI32($value)
	{
	$thing = $this->toZigZag($value, 32);

	return $this->writeVarint($thing);
	}

	public function writeDouble($value)
	{
	$data = pack('d', $value);
	$this->trans_->write($data, 8);

	return 8;
	}

	public function writeString($value)
	{
	$len = TStringFuncFactory::create()->strlen($value);
	$result = $this->writeVarint($len);
	if ($len) {
	$this->trans_->write($value, $len);
	}

	return $result + $len;
	}

	public function readFieldBegin(&$name, &$field_type, &$field_id)
	{
	$result = $this->readUByte($compact_type_and_delta);

	$compact_type = $compact_type_and_delta & 0x0f;

	if ($compact_type == TType::STOP) {
	$field_type = $compact_type;
	$field_id = 0;

	return $result;
	}
	$delta = $compact_type_and_delta >> 4;
	if ($delta == 0) {
	$result += $this->readI16($field_id);
	} else {
	$field_id = $this->lastFid + $delta;
	}
	$this->lastFid = $field_id;
	$field_type = $this->getTType($compact_type);

	if ($compact_type == TCompactProtocol::COMPACT_TRUE) {
	$this->state = TCompactProtocol::STATE_BOOL_READ;
	$this->boolValue = true;
	} elseif ($compact_type == TCompactProtocol::COMPACT_FALSE) {
	$this->state = TCompactProtocol::STATE_BOOL_READ;
	$this->boolValue = false;
	} else {
	$this->state = TCompactProtocol::STATE_VALUE_READ;
	}

	return $result;
	}

	public function readFieldEnd()
	{
	$this->state = TCompactProtocol::STATE_FIELD_READ;

	return 0;
	}

	public function readUByte(&$value)
	{
	$data = $this->trans_->readAll(1);
	$arr = unpack('C', $data);
	$value = $arr[1];

	return 1;
	}

	public function readByte(&$value)
	{
	$data = $this->trans_->readAll(1);
	$arr = unpack('c', $data);
	$value = $arr[1];

	return 1;
	}

	public function readZigZag(&$value)
	{
	$result = $this->readVarint($value);
	$value = $this->fromZigZag($value);

	return $result;
	}

	public function readMessageBegin(&$name, &$type, &$seqid)
	{
	$protoId = 0;
	$result = $this->readUByte($protoId);
	if ($protoId != TCompactProtocol::PROTOCOL_ID) {
	throw new TProtocolException('Bad protocol id in TCompact message');
	}
	$verType = 0;
	$result += $this->readUByte($verType);
	$type = ($verType >> TCompactProtocol::TYPE_SHIFT_AMOUNT) & TCompactProtocol::TYPE_BITS;
	$version = $verType & TCompactProtocol::VERSION_MASK;
	if ($version != TCompactProtocol::VERSION) {
	throw new TProtocolException('Bad version in TCompact message');
	}
	$result += $this->readVarint($seqid);
	$result += $this->readString($name);

	return $result;
	}

	public function readMessageEnd()
	{
	return 0;
	}

	public function readStructBegin(&$name)
	{
	$name = ''; // unused
	$this->structs[] = array($this->state, $this->lastFid);
	$this->state = TCompactProtocol::STATE_FIELD_READ;
	$this->lastFid = 0;

	return 0;
	}

	public function readStructEnd()
	{
	$last = array_pop($this->structs);
	$this->state = $last[0];
	$this->lastFid = $last[1];

	return 0;
	}

	public function readCollectionBegin(&$type, &$size)
	{
	$sizeType = 0;
	$result = $this->readUByte($sizeType);
	$size = $sizeType >> 4;
	$type = $this->getTType($sizeType);
	if ($size == 15) {
	$result += $this->readVarint($size);
	}
	$this->containers[] = $this->state;
	$this->state = TCompactProtocol::STATE_CONTAINER_READ;

	return $result;
	}

	public function readMapBegin(&$key_type, &$val_type, &$size)
	{
	$result = $this->readVarint($size);
	$types = 0;
	if ($size > 0) {
	$result += $this->readUByte($types);
	}
	$val_type = $this->getTType($types);
	$key_type = $this->getTType($types >> 4);
	$this->containers[] = $this->state;
	$this->state = TCompactProtocol::STATE_CONTAINER_READ;

	return $result;
	}

	public function readCollectionEnd()
	{
	$this->state = array_pop($this->containers);

	return 0;
	}

	public function readMapEnd()
	{
	return $this->readCollectionEnd();
	}

	public function readListBegin(&$elem_type, &$size)
	{
	return $this->readCollectionBegin($elem_type, $size);
	}

	public function readListEnd()
	{
	return $this->readCollectionEnd();
	}

	public function readSetBegin(&$elem_type, &$size)
	{
	return $this->readCollectionBegin($elem_type, $size);
	}

	public function readSetEnd()
	{
	return $this->readCollectionEnd();
	}

	public function readBool(&$value)
	{
	if ($this->state == TCompactProtocol::STATE_BOOL_READ) {
	$value = $this->boolValue;

	return 0;
	} elseif ($this->state == TCompactProtocol::STATE_CONTAINER_READ) {
	return $this->readByte($value);
	} else {
	throw new TProtocolException('Invalid state in compact protocol');
	}
	}

	public function readI16(&$value)
	{
	return $this->readZigZag($value);
	}

	public function readI32(&$value)
	{
	return $this->readZigZag($value);
	}

	public function readDouble(&$value)
	{
	$data = $this->trans_->readAll(8);
	$arr = unpack('d', $data);
	$value = $arr[1];

	return 8;
	}

	public function readString(&$value)
	{
	$result = $this->readVarint($len);
	if ($len) {
	$value = $this->trans_->readAll($len);
	} else {
	$value = '';
	}

	return $result + $len;
	}

	public function getTType($byte)
	{
	return self::$ttypes[$byte & 0x0f];
	}

	// 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

	// Read and write I64 as two 32 bit numbers $hi and $lo

	public function readI64(&$value)
	{
	// Read varint from wire
	$hi = 0;
	$lo = 0;

	$idx = 0;
	$shift = 0;

	while (true) {
	$x = $this->trans_->readAll(1);
	$arr = unpack('C', $x);
	$byte = $arr[1];
	$idx += 1;
	// Shift hi and lo together.
	if ($shift < 28) {
	$lo \|= (($byte & 0x7f) << $shift);
	} elseif ($shift == 28) {
	$lo \|= (($byte & 0x0f) << 28);
	$hi \|= (($byte & 0x70) >> 4);
	} else {
	$hi \|= (($byte & 0x7f) << ($shift - 32));
	}
	if (($byte >> 7) === 0) {
	break;
	}
	$shift += 7;
	}

	// Now, unzig it.
	$xorer = 0;
	if ($lo & 1) {
	$xorer = 0xffffffff;
	}
	$lo = ($lo >> 1) & 0x7fffffff;
	$lo = $lo \| (($hi & 1) << 31);
	$hi = ($hi >> 1) ^ $xorer;
	$lo = $lo ^ $xorer;

	// Now put $hi and $lo back together
	$isNeg = $hi < 0 \|\| $hi & 0x80000000;

	// 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 be positive - we deal with sign
	// explicitly below

	if ($hi & (int)0x80000000) {
	$hi &= (int)0x7fffffff;
	$hi += 0x80000000;
	}

	if ($lo & (int)0x80000000) {
	$lo &= (int)0x7fffffff;
	$lo += 0x80000000;
	}

	// Create as negative value first, since we can store -2^63 but not 2^63
	$value = -$hi * 4294967296 - $lo;

	if (!$isNeg) {
	$value = -$value;
	}

	return $idx;
	}

	public function writeI64($value)
	{
	// If we are in an I32 range, use the easy method below.
	if (($value > 4294967296) \|\| ($value < -4294967296)) {
	// Convert $value to $hi and $lo
	$neg = $value < 0;

	if ($neg) {
	$value *= -1;
	}

	$hi = (int)$value >> 32;
	$lo = (int)$value & 0xffffffff;

	if ($neg) {
	$hi = ~$hi;
	$lo = ~$lo;
	if (($lo & (int)0xffffffff) == (int)0xffffffff) {
	$lo = 0;
	$hi++;
	} else {
	$lo++;
	}
	}

	// Now do the zigging and zagging.
	$xorer = 0;
	if ($neg) {
	$xorer = 0xffffffff;
	}
	$lowbit = ($lo >> 31) & 1;
	$hi = ($hi << 1) \| $lowbit;
	$lo = ($lo << 1);
	$lo = ($lo ^ $xorer) & 0xffffffff;
	$hi = ($hi ^ $xorer) & 0xffffffff;

	// now write out the varint, ensuring we shift both hi and lo
	$out = "";
	while (true) {
	if (($lo & ~0x7f) === 0 &&
	$hi === 0) {
	$out .= chr($lo);
	break;
	} else {
	$out .= chr(($lo & 0xff) \| 0x80);
	$lo = $lo >> 7;
	$lo = $lo \| ($hi << 25);
	$hi = $hi >> 7;
	// Right shift carries sign, but we don't want it to.
	$hi = $hi & (127 << 25);
	}
	}

	$ret = TStringFuncFactory::create()->strlen($out);
	$this->trans_->write($out, $ret);

	return $ret;
	} else {
	return $this->writeVarint($this->toZigZag($value, 64));
	}
	}
	}