/**
  * Decodes given value into the on-memory instance in accordance with
  * the predefined codec.
  *
  * @param  mixed $value value to be decoded.
  * @return mixed instance which is decoded.
  */
 public function decode($value)
 {
     if (function_exists('msgpack_unpack')) {
         return msgpack_unpack($value);
     }
     return unserialize($value);
 }

 public function packData($var, $bool = true, $option = array())
 {
     $option += array('packer' => $this->option['packer']);
     switch ($option['packer']) {
         case BoxConstants::ENCODER_JSON:
             if ($bool == true) {
                 return json_encode($var);
             } else {
                 return json_decode($var, true);
             }
             break;
         case BoxConstants::ENCODER_MSGPACK:
             if ($bool == true) {
                 return msgpack_pack($var);
             } else {
                 return msgpack_unpack($var);
             }
             break;
         case BoxConstants::ENCODER_SERIALIZE:
         default:
             if ($bool == true) {
                 return serialize($var);
             } else {
                 return unserialize($var);
             }
             break;
     }
 }

 /**
  * Parse Payload Data
  *
  * @param string $payload
  *
  * @throws ParserException
  *
  * @return array
  */
 public function parse($payload)
 {
     if (function_exists('msgpack_unpack')) {
         if ($payload) {
             $prevHandler = set_error_handler(function ($errno, $errstr, $errfile, $errline, $errcontext) {
                 throw new \Exception($errstr);
                 // @codeCoverageIgnore
             });
             try {
                 $msg = msgpack_unpack(trim($payload));
                 if (!$msg) {
                     throw new \Exception('Unknown error');
                     // @codeCoverageIgnore
                 }
             } catch (\Exception $e) {
                 set_error_handler($prevHandler);
                 throw new ParserException('Failed To Parse MSGPack - ' . $e->getMessage());
             }
             set_error_handler($prevHandler);
             return $msg;
         }
         return [];
     }
     throw new ParserException('Failed To Parse MSGPack - Supporting Library Not Available');
     // @codeCoverageIgnore
 }

 /**
  * @param string $encoded
  * @return mixed
  * @throws \Exception
  */
 public function decode($encoded)
 {
     if (function_exists('msgpack_unpack')) {
         return msgpack_unpack(substr($encoded, 1));
     }
     throw new \Exception('msgpack not installed');
 }

 public function unserialize($string)
 {
     if (!function_exists('msgpack_unpack')) {
         throw new \Exception('msgpack extension must be installed!');
     }
     return msgpack_unpack($string);
 }

 /**
  * Function pretreatment
  * @param $_get
  * @param $_post
  * @param $_version
  * @param $_scope
  * @param $_interface
  * @return array
  */
 public static function get()
 {
     $_tmp_request = [];
     //MAKE URL REQUEST
     //MAKE HTTP HEADER REQUEST
     $_tmp_header_request = [];
     $_tmp_http_accept = explode(';', str_replace(' ', '', strtolower($_SERVER['HTTP_ACCEPT'])));
     $_tmp_request['content-type'] = $_tmp_http_accept[0] == TYPE_JSON || $_tmp_http_accept[0] == TYPE_MSGPACK ? $_tmp_http_accept[0] : TYPE_NULL;
     if (isset($_tmp_http_accept[1]) && !empty($_tmp_http_accept[1])) {
         $_tmp = explode('=', $_tmp_http_accept[1]);
         isset($_tmp[1]) && !empty($_tmp[1]) ? $_tmp_request['version'] = $_tmp[1] : FALSE;
     }
     //@todo Ranges
     //MAKE CONTENT REQUEST
     $_tmp_request['content'] = file_get_contents('php://input');
     switch ($_tmp_request['content-type']) {
         case TYPE_MSGPACK:
             $_tmp_request['content'] = msgpack_unpack($_tmp_request['content']);
             break;
         case TYPE_JSON:
             $_tmp_request['content'] = json_decode($_tmp_request['content']);
             break;
         case TYPE_NULL:
         default:
             $_tmp_request['content'] = NULL;
             break;
     }
     return $_tmp_request;
 }

 public function handleRequest()
 {
     $args = func_get_args();
     $data = $args[0];
     //TODO 简单实用 msgpack
     //FIXME 数据传输协议依赖swoole 底层组包功能，此处不在检查数据完整
     $datastr = substr($data, 4);
     $params = (object) msgpack_unpack($datastr);
     if (empty($params->op)) {
         $params->op = 'main.main';
     }
     //TODO 这里的处理应该完善点
     list($ctrl, $method) = explode('.', $params->op);
     $className = $this->getCtrlNamespace() . '\\' . ucfirst($ctrl) . 'Ctrl';
     $ctrl = new $className();
     $ctrl->setParams($params);
     //发送msgpack编码数据，头部为数据长度
     $result = $ctrl->{$method}();
     if (Ping::$server->debug) {
         echo "swoole handle request:\n";
         echo "\tctrl: {$ctrl} method: {$method}\n";
         echo "\tparams:\n\t\t" . json_encode($params) . "\n";
         echo "\tresponse:\n\t\t" . json_encode($result) . "\n";
         echo "\n\n";
     }
     $rawResult = msgpack_pack($result);
     $rawResult = pack('N1', strlen($rawResult));
     return $rawResult;
 }

 /**
  * 解包工具
  *
  * @param string $raw
  *
  * @return mixed
  */
 public static function unpack($raw, $prefix = true)
 {
     if ($prefix) {
         return msgpack_unpack(substr($raw, 4));
     } else {
         return msgpack_unpack($raw);
     }
 }

 /**
  * Unserializes the data
  *
  * @param array $data data to be unserialized
  *
  * @return array unserialized message
  */
 public function unserialize($data)
 {
     $mssg = msgpack_unpack($data);
     //lets just make UUIDs readable incase we need to debug
     $mssg[0] = Helper::binToUuid($mssg[0]);
     $mssg[1] = Helper::binToUuid($mssg[1]);
     return $mssg;
 }

 public function onData($data, Stream $conn)
 {
     $message = msgpack_unpack($data);
     printf("Request method: %s\n", $message['method']);
     printf("Request params: %s\n", print_r($message['params'], true));
     $result = $this->handler->process($message);
     $conn->write($result);
     $conn->end();
 }

 public function testSend()
 {
     $io = m::mock(Io::class);
     $io->shouldReceive('write')->andReturnUsing(function ($data) {
         self::assertEquals(array(1, 2, 3), msgpack_unpack($data));
     });
     $messenger = new MsgpackMessenger($io);
     $messenger->send(array(1, 2, 3));
 }

 /**
  */
 public function unpack($data)
 {
     ini_set('track_errors', 1);
     $out = @msgpack_unpack($data);
     ini_restore('track_errors');
     if (!isset($php_errormsg)) {
         return $out;
     }
     throw new Horde_Pack_Exception('Error when unpacking Msgpack data.');
 }

 public function parse($rawBody, $contentType)
 {
     if (!extension_loaded('msgpack')) {
         throw new BadRequestHttpException('Msgpack is not supported in this app server');
     }
     $unpacked = @msgpack_unpack($rawBody);
     if ($unpacked === null && $rawBody !== chr(0xc0)) {
         throw new BadRequestHttpException('Invalid MsgPack data in request body');
     }
     return $unpacked;
 }

function test($type, $variable, $test = null)
{
    $serialized = msgpack_pack($variable);
    $unserialized = msgpack_unpack($serialized);
    var_dump($unserialized);
    if (!is_bool($test)) {
        echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
    } else {
        echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
    }
}

function test($type, $variable, $object, $result = null)
{
    $serialized = msgpack_pack($variable);
    $unserialized = msgpack_unpack($serialized, $object);
    var_dump($unserialized);
    if ($result) {
        echo $unserialized == $result ? 'OK' : 'ERROR', PHP_EOL;
    } else {
        echo 'SKIP', PHP_EOL;
    }
}

 public function onReceive($server, $fd, $fromId, $data)
 {
     /**
      * @var \Swoole\Server $server
      */
     $tmp = @msgpack_unpack($data);
     if ($tmp && is_object($tmp)) {
         $data = $tmp;
         unset($tmp);
         if ($data instanceof \stdClass) {
             if ($data->bind) {
                 # 绑定进程ID
                 $server->bind($fd, $data->id);
                 return;
             }
             if ($key = \MyQEE\Server\Register\Client::$host->key) {
                 # 需要解密
                 $data = \MyQEE\Server\RPC\Server::decryption($data, $key);
                 # 解密失败
                 if (!$data) {
                     return;
                 }
             }
             $eof = \MyQEE\Server\RPC\Server::$EOF;
             switch ($data->type) {
                 case 'task':
                 case 'taskWait':
                     $rs = Server::$workerTask->onTask($server, $data->id, $data->wid, $data->data, $data->sid);
                     if ($rs !== null || $data->type === 'taskWait') {
                         # 执行 Finish
                         $rsData = new \stdClass();
                         $rsData->id = $data->id;
                         $rsData->data = $rs;
                         $rsData->wname = $data->wname;
                         if ($key) {
                             # 加密数据
                             $rsData = \MyQEE\Server\RPC\Server::encrypt($rsData, $key) . $eof;
                         } else {
                             # 格式化数据
                             $rsData = msgpack_pack($rsData) . $eof;
                         }
                         $server->send($fd, $rsData, $fromId);
                     }
                     break;
             }
         }
     } else {
         Server::$instance->warn("task server get error msgpack data length: " . strlen($data));
         Server::$instance->debug($data);
         $this->server->close($fd);
     }
 }

 /**
  * 反序列化消息
  *
  * @param string $encodedMsg    序列化的消息内容
  * @return Message | null
  */
 public static function messageUnserialize($serializedMsg)
 {
     $msgArr = msgpack_unpack($serializedMsg);
     if (!isset($msgArr['__lqcmc'])) {
         throw new \Exception('Bad message format');
     }
     if ($msgArr['__lqcmc'] == Message::class) {
         $msg = new Message();
         unset($msgArr['__lqcmc']);
         $msg->initByArray($msgArr);
         return $msg;
     }
 }

function test($type, $var)
{
    echo "================\n" . $type . "\n";
    $e = msgpack_pack($var);
    $d = msgpack_unpack($e);
    echo "\t" . bin2hex($e) . "\t" . $e . "\n\t";
    echo str_replace("\n", "\n\t", var_export($d, true)) . "\n";
    if ($var === $d) {
        echo "PASS\n";
    } else {
        echo "FAIL\n";
    }
}

 /**
  * Parse Payload Data
  *
  * @param string $payload
  *
  * @return array
  *
  * @throws ParserException
  */
 public function parse($payload)
 {
     if (function_exists('msgpack_unpack')) {
         if ($payload) {
             $msg = msgpack_unpack(trim($payload));
             if (!$msg) {
                 throw new ParserException('Failed To Parse MSGPack');
             }
             return $msg;
         }
         return array();
     }
     throw new ParserException('Failed To Parse MSGPack - Supporting Library Not Available');
 }

 protected function decodeVal($str)
 {
     switch ($this->defaultOption['encode']) {
         case 'json':
             return json_decode($str, true);
             break;
         case 'msgpack':
             return msgpack_unpack($str);
             break;
         case 'serialize':
         default:
             return unserialize($str);
             break;
     }
 }