lib/php/src/protocol/TJSONProtocol.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
  */

 /**
  * JSON implementation of thrift protocol, ported from Java.
  */
 class TJSONProtocol extends TProtocol
 {
     const COMMA = ',';
     const COLON = ':';
     const LBRACE = '{';
     const RBRACE = '}';
     const LBRACKET = '[';
     const RBRACKET = ']';
     const QUOTE = '"';
     const BACKSLASH = '\\';
     const ZERO = '0';
     const ESCSEQ = '\\';
     const DOUBLEESC = '__DOUBLE_ESCAPE_SEQUENCE__';

     const VERSION = 1;

     public static $JSON_CHAR_TABLE = array(
         /*  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, // 0
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
         1, 1, '"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
     );

     public static $ESCAPE_CHARS = array('"', '\\', "b", "f", "n", "r", "t");

     public static $ESCAPE_CHAR_VALS = array(
         '"', '\\', "\x08", "\f", "\n", "\r", "\t",
     );

     const NAME_BOOL = "tf";
     const NAME_BYTE = "i8";
     const NAME_I16 = "i16";
     const NAME_I32 = "i32";
     const NAME_I64 = "i64";
     const NAME_DOUBLE = "dbl";
     const NAME_STRUCT = "rec";
     const NAME_STRING = "str";
     const NAME_MAP = "map";
     const NAME_LIST = "lst";
     const NAME_SET = "set";

     private function getTypeNameForTypeID($typeID)
     {
         switch ($typeID) {
             case TType::BOOL:
                 return self::NAME_BOOL;
             case TType::BYTE:
                 return self::NAME_BYTE;
             case TType::I16:
                 return self::NAME_I16;
             case TType::I32:
                 return self::NAME_I32;
             case TType::I64:
                 return self::NAME_I64;
             case TType::DOUBLE:
                 return self::NAME_DOUBLE;
             case TType::STRING:
                 return self::NAME_STRING;
             case TType::STRUCT:
                 return self::NAME_STRUCT;
             case TType::MAP:
                 return self::NAME_MAP;
             case TType::SET:
                 return self::NAME_SET;
             case TType::LST:
                 return self::NAME_LIST;
             default:
                 throw new TProtocolException("Unrecognized type", TProtocolException::UNKNOWN);
         }
     }

     private function getTypeIDForTypeName($name)
     {
         $result = TType::STOP;

         if (strlen($name) > 1) {
             switch (substr($name, 0, 1)) {
                 case 'd':
                     $result = TType::DOUBLE;
                     break;
                 case 'i':
                     switch (substr($name, 1, 1)) {
                         case '8':
                             $result = TType::BYTE;
                             break;
                         case '1':
                             $result = TType::I16;
                             break;
                         case '3':
                             $result = TType::I32;
                             break;
                         case '6':
                             $result = TType::I64;
                             break;
                     }
                     break;
                 case 'l':
                     $result = TType::LST;
                     break;
                 case 'm':
                     $result = TType::MAP;
                     break;
                 case 'r':
                     $result = TType::STRUCT;
                     break;
                 case 's':
                     if (substr($name, 1, 1) == 't') {
                         $result = TType::STRING;
                     }
                     else if (substr($name, 1, 1) == 'e') {
                         $result = TType::SET;
                     }
                     break;
                 case 't':
                     $result = TType::BOOL;
                     break;
             }
         }
         if ($result == TType::STOP) {
             throw new TProtocolException("Unrecognized type", TProtocolException::INVALID_DATA);
         }
         return $result;
     }

     public $contextStack_ = array();
     public $context_;
     public $reader_;

     private function pushContext($c) {
         array_push($this->contextStack_, $this->context_);
         $this->context_ = $c;
     }

     private function popContext() {
         $this->context_ = array_pop($this->contextStack_);
     }

     public function __construct($trans) {
         parent::__construct($trans);
         $this->context_ = new TJSONProtocol_JSONBaseContext();
         $this->reader_ = new TJSONProtocol_LookaheadReader($this);
     }

     public function reset() {
         $this->contextStack_ = array();
         $this->context_ = new TJSONProtocol_JSONBaseContext();
         $this->reader_ = new TJSONProtocol_LookaheadReader($this);
     }

     private $tmpbuf_ = array(4);

     public function readJSONSyntaxChar($b) {
         $ch = $this->reader_->read();

         if (substr($ch, 0, 1) != $b) {
             throw new TProtocolException("Unexpected character: " . $ch, TProtocolException::INVALID_DATA);
         }
     }

     private function hexVal($s) {
         for ($i = 0; $i < strlen($s); $i++) {
             $ch = substr($s, $i, 1);

             if (!($ch >= "a" && $ch <= "f") && !($ch >= "0" && $ch <= "9")) {
                 throw new TProtocolException("Expected hex character " . $ch, TProtocolException::INVALID_DATA);
             }
         }

         return hexdec($s);
     }

     private function hexChar($val) {
         return dechex($val);
     }

     private function writeJSONString($b) {
         $this->context_->write();

         if (is_numeric($b) && $this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }

         $this->trans_->write(json_encode($b));

         if (is_numeric($b) && $this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }
     }

     private function writeJSONInteger($num) {
         $this->context_->write();

         if ($this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }

         $this->trans_->write($num);

         if ($this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }
     }

     private function writeJSONDouble($num) {
         $this->context_->write();

         if ($this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }

         $this->trans_->write(json_encode($num));

         if ($this->context_->escapeNum()) {
             $this->trans_->write(self::QUOTE);
         }
     }

     private function writeJSONBase64($data) {
         $this->context_->write();
         $this->trans_->write(self::QUOTE);
         $this->trans_->write(json_encode(base64_encode($data)));
         $this->trans_->write(self::QUOTE);
     }

     private function writeJSONObjectStart() {
       $this->context_->write();
       $this->trans_->write(self::LBRACE);
       $this->pushContext(new TJSONProtocol_JSONPairContext($this));
     }

     private function writeJSONObjectEnd() {
       $this->popContext();
       $this->trans_->write(self::RBRACE);
     }

     private function writeJSONArrayStart() {
       $this->context_->write();
       $this->trans_->write(self::LBRACKET);
       $this->pushContext(new TJSONProtocol_JSONListContext($this));
     }

     private function writeJSONArrayEnd() {
       $this->popContext();
       $this->trans_->write(self::RBRACKET);
     }

     private function readJSONString($skipContext) {
       if (!$skipContext) {
         $this->context_->read();
       }

       $jsonString = '';
       $lastChar = NULL;
       while (true) {
         $ch = $this->reader_->read();
         $jsonString .= $ch;
         if ($ch == self::QUOTE &&
           $lastChar !== NULL &&
             $lastChar !== self::ESCSEQ) {
           break;
         }
         if ($ch == self::ESCSEQ && $lastChar == self::ESCSEQ) {
           $lastChar = self::DOUBLEESC;
         } else {
           $lastChar = $ch;
         }
       }
       return json_decode($jsonString);
     }

     private function isJSONNumeric($b) {
         switch ($b) {
             case '+':
             case '-':
             case '.':
             case '0':
             case '1':
             case '2':
             case '3':
             case '4':
             case '5':
             case '6':
             case '7':
             case '8':
             case '9':
             case 'E':
             case 'e':
               return true;
             }
         return false;
     }

     private function readJSONNumericChars() {
         $strbld = array();

         while (true) {
             $ch = $this->reader_->peek();

             if (!$this->isJSONNumeric($ch)) {
                 break;
             }

             $strbld[] = $this->reader_->read();
         }

         return implode("", $strbld);
     }

     private function readJSONInteger() {
         $this->context_->read();

         if ($this->context_->escapeNum()) {
             $this->readJSONSyntaxChar(self::QUOTE);
         }

         $str = $this->readJSONNumericChars();

         if ($this->context_->escapeNum()) {
             $this->readJSONSyntaxChar(self::QUOTE);
         }

         if (!is_numeric($str)) {
             throw new TProtocolException("Invalid data in numeric: " . $str, TProtocolException::INVALID_DATA);
         }

         return intval($str);
     }

     /**
      * Identical to readJSONInteger but without the final cast.
      * Needed for proper handling of i64 on 32 bit machines.  Why a
      * separate function?  So we don't have to force the rest of the
      * use cases through the extra conditional.
      */
     private function readJSONIntegerAsString() {
         $this->context_->read();

         if ($this->context_->escapeNum()) {
             $this->readJSONSyntaxChar(self::QUOTE);
         }

         $str = $this->readJSONNumericChars();

         if ($this->context_->escapeNum()) {
             $this->readJSONSyntaxChar(self::QUOTE);
         }

         if (!is_numeric($str)) {
             throw new TProtocolException("Invalid data in numeric: " . $str, TProtocolException::INVALID_DATA);
         }

         return $str;
     }

     private function readJSONDouble() {
         $this->context_->read();

         if (substr($this->reader_->peek(), 0, 1) == self::QUOTE) {
             $arr = $this->readJSONString(true);

             if ($arr == "NaN") {
                 return NAN;
             } else if ($arr == "Infinity") {
                 return INF;
             } else if (!$this->context_->escapeNum()) {
                 throw new TProtocolException("Numeric data unexpectedly quoted " . $arr,
                                               TProtocolException::INVALID_DATA);
             }

             return floatval($arr);
         } else {
             if ($this->context_->escapeNum()) {
                 $this->readJSONSyntaxChar(self::QUOTE);
             }

             return floatval($this->readJSONNumericChars());
         }
     }

     private function readJSONBase64() {
         $arr = $this->readJSONString(false);
         $data = base64_decode($arr, true);

         if ($data === false) {
             throw new TProtocolException("Invalid base64 data " . $arr, TProtocolException::INVALID_DATA);
         }

         return $data;
     }

     private function readJSONObjectStart() {
         $this->context_->read();
         $this->readJSONSyntaxChar(self::LBRACE);
         $this->pushContext(new TJSONProtocol_JSONPairContext($this));
     }

     private function readJSONObjectEnd() {
         $this->readJSONSyntaxChar(self::RBRACE);
         $this->popContext();
     }

     private function readJSONArrayStart()
     {
         $this->context_->read();
         $this->readJSONSyntaxChar(self::LBRACKET);
         $this->pushContext(new TJSONProtocol_JSONListContext($this));
     }

     private function readJSONArrayEnd() {
         $this->readJSONSyntaxChar(self::RBRACKET);
         $this->popContext();
     }

     /**
      * Writes the message header
      *
      * @param string $name Function name
      * @param int $type message type TMessageType::CALL or TMessageType::REPLY
      * @param int $seqid The sequence id of this message
      */
     public function writeMessageBegin($name, $type, $seqid) {
         $this->writeJSONArrayStart();
         $this->writeJSONInteger(self::VERSION);
         $this->writeJSONString($name);
         $this->writeJSONInteger($type);
         $this->writeJSONInteger($seqid);
     }

     /**
      * Close the message
      */
     public function writeMessageEnd() {
         $this->writeJSONArrayEnd();
     }

     /**
      * Writes a struct header.
      *
      * @param string     $name Struct name
      * @throws TException on write error
      * @return int How many bytes written
      */
     public function writeStructBegin($name) {
         $this->writeJSONObjectStart();
     }

     /**
      * Close a struct.
      *
      * @throws TException on write error
      * @return int How many bytes written
      */
     public function writeStructEnd() {
         $this->writeJSONObjectEnd();
     }

     public function writeFieldBegin($fieldName, $fieldType, $fieldId) {
         $this->writeJSONInteger($fieldId);
         $this->writeJSONObjectStart();
         $this->writeJSONString($this->getTypeNameForTypeID($fieldType));
     }

     public function writeFieldEnd() {
         $this->writeJsonObjectEnd();
     }

     public function writeFieldStop() {
     }

     public function writeMapBegin($keyType, $valType, $size) {
         $this->writeJSONArrayStart();
         $this->writeJSONString($this->getTypeNameForTypeID($keyType));
         $this->writeJSONString($this->getTypeNameForTypeID($valType));
         $this->writeJSONInteger($size);
         $this->writeJSONObjectStart();
     }

     public function writeMapEnd() {
         $this->writeJSONObjectEnd();
         $this->writeJSONArrayEnd();
     }

     public function writeListBegin($elemType, $size) {
         $this->writeJSONArrayStart();
         $this->writeJSONString($this->getTypeNameForTypeID($elemType));
         $this->writeJSONInteger($size);
     }

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

     public function writeSetBegin($elemType, $size) {
         $this->writeJSONArrayStart();
         $this->writeJSONString($this->getTypeNameForTypeID($elemType));
         $this->writeJSONInteger($size);
     }

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

     public function writeBool($bool) {
         $this->writeJSONInteger($bool ? 1 : 0);
     }

     public function writeByte($byte) {
         $this->writeJSONInteger($byte);
     }

     public function writeI16($i16) {
         $this->writeJSONInteger($i16);
     }

     public function writeI32($i32) {
         $this->writeJSONInteger($i32);
     }

     public function writeI64($i64) {
         $this->writeJSONInteger($i64);
     }

     public function writeDouble($dub) {
         $this->writeJSONDouble($dub);
     }

     public function writeString($str) {
         $this->writeJSONString($str);
     }

     /**
      * Reads the message header
      *
      * @param string $name Function name
      * @param int $type message type TMessageType::CALL or TMessageType::REPLY
      * @parem int $seqid The sequence id of this message
      */
     public function readMessageBegin(&$name, &$type, &$seqid) {
         $this->readJSONArrayStart();

         if ($this->readJSONInteger() != self::VERSION) {
             throw new TProtocolException("Message contained bad version", TProtocolException::BAD_VERSION);
         }

         $name = $this->readJSONString(false);
         $type = $this->readJSONInteger();
         $seqid = $this->readJSONInteger();

         return true;
     }

     /**
      * Read the close of message
      */
     public function readMessageEnd() {
         $this->readJSONArrayEnd();
     }

     public function readStructBegin(&$name) {
         $this->readJSONObjectStart();
         return 0;
     }

     public function readStructEnd() {
         $this->readJSONObjectEnd();
     }

     public function readFieldBegin(&$name, &$fieldType, &$fieldId) {
         $ch = $this->reader_->peek();
         $name = "";

         if (substr($ch, 0, 1) == self::RBRACE) {
             $fieldType = TType::STOP;
         } else {
             $fieldId = $this->readJSONInteger();
             $this->readJSONObjectStart();
             $fieldType = $this->getTypeIDForTypeName($this->readJSONString(false));
         }
     }

     public function readFieldEnd() {
         $this->readJSONObjectEnd();
     }

     public function readMapBegin(&$keyType, &$valType, &$size) {
         $this->readJSONArrayStart();
         $keyType = $this->getTypeIDForTypeName($this->readJSONString(false));
         $valType = $this->getTypeIDForTypeName($this->readJSONString(false));
         $size = $this->readJSONInteger();
         $this->readJSONObjectStart();
     }

     public function readMapEnd() {
         $this->readJSONObjectEnd();
         $this->readJSONArrayEnd();
     }

     public function readListBegin(&$elemType, &$size) {
         $this->readJSONArrayStart();
         $elemType = $this->getTypeIDForTypeName($this->readJSONString(false));
         $size = $this->readJSONInteger();
         return true;
     }

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

     public function readSetBegin(&$elemType, &$size) {
         $this->readJSONArrayStart();
         $elemType = $this->getTypeIDForTypeName($this->readJSONString(false));
         $size = $this->readJSONInteger();
         return true;
     }

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

     public function readBool(&$bool) {
         $bool = $this->readJSONInteger() == 0 ? false : true;
         return true;
     }

     public function readByte(&$byte) {
         $byte = $this->readJSONInteger();
         return true;
     }

     public function readI16(&$i16) {
         $i16 = $this->readJSONInteger();
         return true;
     }

     public function readI32(&$i32) {
         $i32 = $this->readJSONInteger();
         return true;
     }

     public function readI64(&$i64) {
         if ( PHP_INT_SIZE === 4 ) {
             $i64 = $this->readJSONIntegerAsString();
         } else {
             $i64 = $this->readJSONInteger();
         }
         return true;
     }

     public function readDouble(&$dub) {
         $dub = $this->readJSONDouble();
         return true;
     }

     public function readString(&$str) {
         $str = $this->readJSONString(false);
         return true;
     }
 }

 /**
  * JSON Protocol Factory
  */
 class TJSONProtocolFactory implements TProtocolFactory
 {
     public function __construct()
     {
     }

     public function getProtocol($trans)
     {
         return new TJSONProtocol($trans);
     }
 }

 class TJSONProtocol_JSONBaseContext
 {
     function escapeNum()
     {
         return false;
     }

     function write()
     {
     }

     function read()
     {
     }
 }

 class TJSONProtocol_JSONListContext extends TJSONProtocol_JSONBaseContext
 {
     private $first_ = true;
     private $p_;

     public function __construct($p) {
         $this->p_ = $p;
     }

     public function write() {
         if ($this->first_) {
             $this->first_ = false;
         } else {
             $this->p_->getTransport()->write(TJSONProtocol::COMMA);
         }
     }

     public function read() {
         if ($this->first_) {
             $this->first_ = false;
         } else {
             $this->p_->readJSONSyntaxChar(TJSONProtocol::COMMA);
         }
     }
 }

 class TJSONProtocol_JSONPairContext extends TJSONProtocol_JSONBaseContext {
     private $first_ = true;
     private $colon_ = true;
     private $p_ = null;

     public function __construct($p) {
         $this->p_ = $p;
     }

     public function write() {
         if ($this->first_) {
             $this->first_ = false;
             $this->colon_ = true;
         } else {
             $this->p_->getTransport()->write($this->colon_ ? TJSONProtocol::COLON : TJSONProtocol::COMMA);
             $this->colon_ = !$this->colon_;
         }
     }

     public function read() {
         if ($this->first_) {
             $this->first_ = false;
             $this->colon_ = true;
         } else {
             $this->p_->readJSONSyntaxChar($this->colon_ ? TJSONProtocol::COLON : TJSONProtocol::COMMA);
             $this->colon_ = !$this->colon_;
         }
     }

     public function escapeNum() {
         return $this->colon_;
     }
 }

 class TJSONProtocol_LookaheadReader
 {
     private $hasData_ = false;
     private $data_ = array();
     private $p_;

     public function __construct($p)
     {
         $this->p_ = $p;
     }

     public function read() {
         if ($this->hasData_) {
             $this->hasData_ = false;
         } else {
             $this->data_ = $this->p_->getTransport()->readAll(1);
         }

         return substr($this->data_, 0, 1);
     }

     public function peek() {
         if (!$this->hasData_) {
             $this->data_ = $this->p_->getTransport()->readAll(1);
         }

         $this->hasData_ = true;
         return substr($this->data_, 0, 1);
     }
 }
	<?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
	*/

	/**
	* JSON implementation of thrift protocol, ported from Java.
	*/
	class TJSONProtocol extends TProtocol
	{
	const COMMA = ',';
	const COLON = ':';
	const LBRACE = '{';
	const RBRACE = '}';
	const LBRACKET = '[';
	const RBRACKET = ']';
	const QUOTE = '"';
	const BACKSLASH = '\\';
	const ZERO = '0';
	const ESCSEQ = '\\';
	const DOUBLEESC = '__DOUBLE_ESCAPE_SEQUENCE__';

	const VERSION = 1;

	public static $JSON_CHAR_TABLE = array(
	/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
	0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, // 0
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
	1, 1, '"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
	);

	public static $ESCAPE_CHARS = array('"', '\\', "b", "f", "n", "r", "t");

	public static $ESCAPE_CHAR_VALS = array(
	'"', '\\', "\x08", "\f", "\n", "\r", "\t",
	);

	const NAME_BOOL = "tf";
	const NAME_BYTE = "i8";
	const NAME_I16 = "i16";
	const NAME_I32 = "i32";
	const NAME_I64 = "i64";
	const NAME_DOUBLE = "dbl";
	const NAME_STRUCT = "rec";
	const NAME_STRING = "str";
	const NAME_MAP = "map";
	const NAME_LIST = "lst";
	const NAME_SET = "set";

	private function getTypeNameForTypeID($typeID)
	{
	switch ($typeID) {
	case TType::BOOL:
	return self::NAME_BOOL;
	case TType::BYTE:
	return self::NAME_BYTE;
	case TType::I16:
	return self::NAME_I16;
	case TType::I32:
	return self::NAME_I32;
	case TType::I64:
	return self::NAME_I64;
	case TType::DOUBLE:
	return self::NAME_DOUBLE;
	case TType::STRING:
	return self::NAME_STRING;
	case TType::STRUCT:
	return self::NAME_STRUCT;
	case TType::MAP:
	return self::NAME_MAP;
	case TType::SET:
	return self::NAME_SET;
	case TType::LST:
	return self::NAME_LIST;
	default:
	throw new TProtocolException("Unrecognized type", TProtocolException::UNKNOWN);
	}
	}

	private function getTypeIDForTypeName($name)
	{
	$result = TType::STOP;

	if (strlen($name) > 1) {
	switch (substr($name, 0, 1)) {
	case 'd':
	$result = TType::DOUBLE;
	break;
	case 'i':
	switch (substr($name, 1, 1)) {
	case '8':
	$result = TType::BYTE;
	break;
	case '1':
	$result = TType::I16;
	break;
	case '3':
	$result = TType::I32;
	break;
	case '6':
	$result = TType::I64;
	break;
	}
	break;
	case 'l':
	$result = TType::LST;
	break;
	case 'm':
	$result = TType::MAP;
	break;
	case 'r':
	$result = TType::STRUCT;
	break;
	case 's':
	if (substr($name, 1, 1) == 't') {
	$result = TType::STRING;
	}
	else if (substr($name, 1, 1) == 'e') {
	$result = TType::SET;
	}
	break;
	case 't':
	$result = TType::BOOL;
	break;
	}
	}
	if ($result == TType::STOP) {
	throw new TProtocolException("Unrecognized type", TProtocolException::INVALID_DATA);
	}
	return $result;
	}

	public $contextStack_ = array();
	public $context_;
	public $reader_;

	private function pushContext($c) {
	array_push($this->contextStack_, $this->context_);
	$this->context_ = $c;
	}

	private function popContext() {
	$this->context_ = array_pop($this->contextStack_);
	}

	public function __construct($trans) {
	parent::__construct($trans);
	$this->context_ = new TJSONProtocol_JSONBaseContext();
	$this->reader_ = new TJSONProtocol_LookaheadReader($this);
	}

	public function reset() {
	$this->contextStack_ = array();
	$this->context_ = new TJSONProtocol_JSONBaseContext();
	$this->reader_ = new TJSONProtocol_LookaheadReader($this);
	}

	private $tmpbuf_ = array(4);

	public function readJSONSyntaxChar($b) {
	$ch = $this->reader_->read();

	if (substr($ch, 0, 1) != $b) {
	throw new TProtocolException("Unexpected character: " . $ch, TProtocolException::INVALID_DATA);
	}
	}

	private function hexVal($s) {
	for ($i = 0; $i < strlen($s); $i++) {
	$ch = substr($s, $i, 1);

	if (!($ch >= "a" && $ch <= "f") && !($ch >= "0" && $ch <= "9")) {
	throw new TProtocolException("Expected hex character " . $ch, TProtocolException::INVALID_DATA);
	}
	}

	return hexdec($s);
	}

	private function hexChar($val) {
	return dechex($val);
	}

	private function writeJSONString($b) {
	$this->context_->write();

	if (is_numeric($b) && $this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}

	$this->trans_->write(json_encode($b));

	if (is_numeric($b) && $this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}
	}

	private function writeJSONInteger($num) {
	$this->context_->write();

	if ($this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}

	$this->trans_->write($num);

	if ($this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}
	}

	private function writeJSONDouble($num) {
	$this->context_->write();

	if ($this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}

	$this->trans_->write(json_encode($num));

	if ($this->context_->escapeNum()) {
	$this->trans_->write(self::QUOTE);
	}
	}

	private function writeJSONBase64($data) {
	$this->context_->write();
	$this->trans_->write(self::QUOTE);
	$this->trans_->write(json_encode(base64_encode($data)));
	$this->trans_->write(self::QUOTE);
	}

	private function writeJSONObjectStart() {
	$this->context_->write();
	$this->trans_->write(self::LBRACE);
	$this->pushContext(new TJSONProtocol_JSONPairContext($this));
	}

	private function writeJSONObjectEnd() {
	$this->popContext();
	$this->trans_->write(self::RBRACE);
	}

	private function writeJSONArrayStart() {
	$this->context_->write();
	$this->trans_->write(self::LBRACKET);
	$this->pushContext(new TJSONProtocol_JSONListContext($this));
	}

	private function writeJSONArrayEnd() {
	$this->popContext();
	$this->trans_->write(self::RBRACKET);
	}

	private function readJSONString($skipContext) {
	if (!$skipContext) {
	$this->context_->read();
	}

	$jsonString = '';
	$lastChar = NULL;
	while (true) {
	$ch = $this->reader_->read();
	$jsonString .= $ch;
	if ($ch == self::QUOTE &&
	$lastChar !== NULL &&
	$lastChar !== self::ESCSEQ) {
	break;
	}
	if ($ch == self::ESCSEQ && $lastChar == self::ESCSEQ) {
	$lastChar = self::DOUBLEESC;
	} else {
	$lastChar = $ch;
	}
	}
	return json_decode($jsonString);
	}

	private function isJSONNumeric($b) {
	switch ($b) {
	case '+':
	case '-':
	case '.':
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	case 'E':
	case 'e':
	return true;
	}
	return false;
	}

	private function readJSONNumericChars() {
	$strbld = array();

	while (true) {
	$ch = $this->reader_->peek();

	if (!$this->isJSONNumeric($ch)) {
	break;
	}

	$strbld[] = $this->reader_->read();
	}

	return implode("", $strbld);
	}

	private function readJSONInteger() {
	$this->context_->read();

	if ($this->context_->escapeNum()) {
	$this->readJSONSyntaxChar(self::QUOTE);
	}

	$str = $this->readJSONNumericChars();

	if ($this->context_->escapeNum()) {
	$this->readJSONSyntaxChar(self::QUOTE);
	}

	if (!is_numeric($str)) {
	throw new TProtocolException("Invalid data in numeric: " . $str, TProtocolException::INVALID_DATA);
	}

	return intval($str);
	}

	/**
	* Identical to readJSONInteger but without the final cast.
	* Needed for proper handling of i64 on 32 bit machines. Why a
	* separate function? So we don't have to force the rest of the
	* use cases through the extra conditional.
	*/
	private function readJSONIntegerAsString() {
	$this->context_->read();

	if ($this->context_->escapeNum()) {
	$this->readJSONSyntaxChar(self::QUOTE);
	}

	$str = $this->readJSONNumericChars();

	if ($this->context_->escapeNum()) {
	$this->readJSONSyntaxChar(self::QUOTE);
	}

	if (!is_numeric($str)) {
	throw new TProtocolException("Invalid data in numeric: " . $str, TProtocolException::INVALID_DATA);
	}

	return $str;
	}

	private function readJSONDouble() {
	$this->context_->read();

	if (substr($this->reader_->peek(), 0, 1) == self::QUOTE) {
	$arr = $this->readJSONString(true);

	if ($arr == "NaN") {
	return NAN;
	} else if ($arr == "Infinity") {
	return INF;
	} else if (!$this->context_->escapeNum()) {
	throw new TProtocolException("Numeric data unexpectedly quoted " . $arr,
	TProtocolException::INVALID_DATA);
	}

	return floatval($arr);
	} else {
	if ($this->context_->escapeNum()) {
	$this->readJSONSyntaxChar(self::QUOTE);
	}

	return floatval($this->readJSONNumericChars());
	}
	}

	private function readJSONBase64() {
	$arr = $this->readJSONString(false);
	$data = base64_decode($arr, true);

	if ($data === false) {
	throw new TProtocolException("Invalid base64 data " . $arr, TProtocolException::INVALID_DATA);
	}

	return $data;
	}

	private function readJSONObjectStart() {
	$this->context_->read();
	$this->readJSONSyntaxChar(self::LBRACE);
	$this->pushContext(new TJSONProtocol_JSONPairContext($this));
	}

	private function readJSONObjectEnd() {
	$this->readJSONSyntaxChar(self::RBRACE);
	$this->popContext();
	}

	private function readJSONArrayStart()
	{
	$this->context_->read();
	$this->readJSONSyntaxChar(self::LBRACKET);
	$this->pushContext(new TJSONProtocol_JSONListContext($this));
	}

	private function readJSONArrayEnd() {
	$this->readJSONSyntaxChar(self::RBRACKET);
	$this->popContext();
	}

	/**
	* Writes the message header
	*
	* @param string $name Function name
	* @param int $type message type TMessageType::CALL or TMessageType::REPLY
	* @param int $seqid The sequence id of this message
	*/
	public function writeMessageBegin($name, $type, $seqid) {
	$this->writeJSONArrayStart();
	$this->writeJSONInteger(self::VERSION);
	$this->writeJSONString($name);
	$this->writeJSONInteger($type);
	$this->writeJSONInteger($seqid);
	}

	/**
	* Close the message
	*/
	public function writeMessageEnd() {
	$this->writeJSONArrayEnd();
	}

	/**
	* Writes a struct header.
	*
	* @param string $name Struct name
	* @throws TException on write error
	* @return int How many bytes written
	*/
	public function writeStructBegin($name) {
	$this->writeJSONObjectStart();
	}

	/**
	* Close a struct.
	*
	* @throws TException on write error
	* @return int How many bytes written
	*/
	public function writeStructEnd() {
	$this->writeJSONObjectEnd();
	}

	public function writeFieldBegin($fieldName, $fieldType, $fieldId) {
	$this->writeJSONInteger($fieldId);
	$this->writeJSONObjectStart();
	$this->writeJSONString($this->getTypeNameForTypeID($fieldType));
	}

	public function writeFieldEnd() {
	$this->writeJsonObjectEnd();
	}

	public function writeFieldStop() {
	}

	public function writeMapBegin($keyType, $valType, $size) {
	$this->writeJSONArrayStart();
	$this->writeJSONString($this->getTypeNameForTypeID($keyType));
	$this->writeJSONString($this->getTypeNameForTypeID($valType));
	$this->writeJSONInteger($size);
	$this->writeJSONObjectStart();
	}

	public function writeMapEnd() {
	$this->writeJSONObjectEnd();
	$this->writeJSONArrayEnd();
	}

	public function writeListBegin($elemType, $size) {
	$this->writeJSONArrayStart();
	$this->writeJSONString($this->getTypeNameForTypeID($elemType));
	$this->writeJSONInteger($size);
	}

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

	public function writeSetBegin($elemType, $size) {
	$this->writeJSONArrayStart();
	$this->writeJSONString($this->getTypeNameForTypeID($elemType));
	$this->writeJSONInteger($size);
	}

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

	public function writeBool($bool) {
	$this->writeJSONInteger($bool ? 1 : 0);
	}

	public function writeByte($byte) {
	$this->writeJSONInteger($byte);
	}

	public function writeI16($i16) {
	$this->writeJSONInteger($i16);
	}

	public function writeI32($i32) {
	$this->writeJSONInteger($i32);
	}

	public function writeI64($i64) {
	$this->writeJSONInteger($i64);
	}

	public function writeDouble($dub) {
	$this->writeJSONDouble($dub);
	}

	public function writeString($str) {
	$this->writeJSONString($str);
	}

	/**
	* Reads the message header
	*
	* @param string $name Function name
	* @param int $type message type TMessageType::CALL or TMessageType::REPLY
	* @parem int $seqid The sequence id of this message
	*/
	public function readMessageBegin(&$name, &$type, &$seqid) {
	$this->readJSONArrayStart();

	if ($this->readJSONInteger() != self::VERSION) {
	throw new TProtocolException("Message contained bad version", TProtocolException::BAD_VERSION);
	}

	$name = $this->readJSONString(false);
	$type = $this->readJSONInteger();
	$seqid = $this->readJSONInteger();

	return true;
	}

	/**
	* Read the close of message
	*/
	public function readMessageEnd() {
	$this->readJSONArrayEnd();
	}

	public function readStructBegin(&$name) {
	$this->readJSONObjectStart();
	return 0;
	}

	public function readStructEnd() {
	$this->readJSONObjectEnd();
	}

	public function readFieldBegin(&$name, &$fieldType, &$fieldId) {
	$ch = $this->reader_->peek();
	$name = "";

	if (substr($ch, 0, 1) == self::RBRACE) {
	$fieldType = TType::STOP;
	} else {
	$fieldId = $this->readJSONInteger();
	$this->readJSONObjectStart();
	$fieldType = $this->getTypeIDForTypeName($this->readJSONString(false));
	}
	}

	public function readFieldEnd() {
	$this->readJSONObjectEnd();
	}

	public function readMapBegin(&$keyType, &$valType, &$size) {
	$this->readJSONArrayStart();
	$keyType = $this->getTypeIDForTypeName($this->readJSONString(false));
	$valType = $this->getTypeIDForTypeName($this->readJSONString(false));
	$size = $this->readJSONInteger();
	$this->readJSONObjectStart();
	}

	public function readMapEnd() {
	$this->readJSONObjectEnd();
	$this->readJSONArrayEnd();
	}

	public function readListBegin(&$elemType, &$size) {
	$this->readJSONArrayStart();
	$elemType = $this->getTypeIDForTypeName($this->readJSONString(false));
	$size = $this->readJSONInteger();
	return true;
	}

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

	public function readSetBegin(&$elemType, &$size) {
	$this->readJSONArrayStart();
	$elemType = $this->getTypeIDForTypeName($this->readJSONString(false));
	$size = $this->readJSONInteger();
	return true;
	}

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

	public function readBool(&$bool) {
	$bool = $this->readJSONInteger() == 0 ? false : true;
	return true;
	}

	public function readByte(&$byte) {
	$byte = $this->readJSONInteger();
	return true;
	}

	public function readI16(&$i16) {
	$i16 = $this->readJSONInteger();
	return true;
	}

	public function readI32(&$i32) {
	$i32 = $this->readJSONInteger();
	return true;
	}

	public function readI64(&$i64) {
	if ( PHP_INT_SIZE === 4 ) {
	$i64 = $this->readJSONIntegerAsString();
	} else {
	$i64 = $this->readJSONInteger();
	}
	return true;
	}

	public function readDouble(&$dub) {
	$dub = $this->readJSONDouble();
	return true;
	}

	public function readString(&$str) {
	$str = $this->readJSONString(false);
	return true;
	}
	}

	/**
	* JSON Protocol Factory
	*/
	class TJSONProtocolFactory implements TProtocolFactory
	{
	public function __construct()
	{
	}

	public function getProtocol($trans)
	{
	return new TJSONProtocol($trans);
	}
	}

	class TJSONProtocol_JSONBaseContext
	{
	function escapeNum()
	{
	return false;
	}

	function write()
	{
	}

	function read()
	{
	}
	}

	class TJSONProtocol_JSONListContext extends TJSONProtocol_JSONBaseContext
	{
	private $first_ = true;
	private $p_;

	public function __construct($p) {
	$this->p_ = $p;
	}

	public function write() {
	if ($this->first_) {
	$this->first_ = false;
	} else {
	$this->p_->getTransport()->write(TJSONProtocol::COMMA);
	}
	}

	public function read() {
	if ($this->first_) {
	$this->first_ = false;
	} else {
	$this->p_->readJSONSyntaxChar(TJSONProtocol::COMMA);
	}
	}
	}

	class TJSONProtocol_JSONPairContext extends TJSONProtocol_JSONBaseContext {
	private $first_ = true;
	private $colon_ = true;
	private $p_ = null;

	public function __construct($p) {
	$this->p_ = $p;
	}

	public function write() {
	if ($this->first_) {
	$this->first_ = false;
	$this->colon_ = true;
	} else {
	$this->p_->getTransport()->write($this->colon_ ? TJSONProtocol::COLON : TJSONProtocol::COMMA);
	$this->colon_ = !$this->colon_;
	}
	}

	public function read() {
	if ($this->first_) {
	$this->first_ = false;
	$this->colon_ = true;
	} else {
	$this->p_->readJSONSyntaxChar($this->colon_ ? TJSONProtocol::COLON : TJSONProtocol::COMMA);
	$this->colon_ = !$this->colon_;
	}
	}

	public function escapeNum() {
	return $this->colon_;
	}
	}

	class TJSONProtocol_LookaheadReader
	{
	private $hasData_ = false;
	private $data_ = array();
	private $p_;

	public function __construct($p)
	{
	$this->p_ = $p;
	}

	public function read() {
	if ($this->hasData_) {
	$this->hasData_ = false;
	} else {
	$this->data_ = $this->p_->getTransport()->readAll(1);
	}

	return substr($this->data_, 0, 1);
	}

	public function peek() {
	if (!$this->hasData_) {
	$this->data_ = $this->p_->getTransport()->readAll(1);
	}

	$this->hasData_ = true;
	return substr($this->data_, 0, 1);
	}
	}