/**
  * @param mixed $data Data to unserialize
  * @param bool|true $useIgBinary Use igBinary extension if supported
  *
  * @return string
  */
 protected function phpUnserialize($data, $useIgBinary = true)
 {
     if ($this->isIgBinarySupported() && $useIgBinary) {
         return igbinary_unserialize($data);
     }
     return unserialize($data);
 }

 public function unserialize($data)
 {
     if ($this->igbinary) {
         return igbinary_unserialize($data);
     }
     return unserialize($data);
 }

	protected function unserialize ($value) {
		if ($this->igbinary) {
			return igbinary_unserialize($value);
		}

		return unserialize($value);
	}

 /**
  * Attempt to retrieve a value from the cache server, if not set it.
  *
  * @param string $key Key we can use to retrieve the data.
  *
  * @return bool|string False on failure or String, data belonging to the key.
  * @access public
  */
 public function get($key)
 {
     if ($this->connected === true && $this->ping() === true) {
         $data = $this->server->get($key);
         return $this->isRedis ? $this->IgBinarySupport ? igbinary_unserialize($data) : unserialize($data) : $data;
     }
     return false;
 }

 private function _tempData_unserialize($data)
 {
     if (true === $this->_has_igbinary_status) {
         return igbinary_unserialize($data);
     } else {
         return unserialize($data);
     }
 }

 private static function unserialize($o)
 {
     $igbinary = extension_loaded('igbinary');
     if ($igbinary) {
         return @igbinary_unserialize($o);
     }
     return @unserialize($o);
 }

 /**
  */
 public function unpack($data)
 {
     $out = igbinary_unserialize($data);
     if (!is_null($out) || $data == igbinary_serialize(null)) {
         return $out;
     }
     throw new Horde_Pack_Exception('Error when unpacking serialized data.');
 }

/**
 * @param $val
 * @return mixed
 */
function unserialize($val)
{
    if (function_exists('igbinary_unserialize')) {
        return \igbinary_unserialize($val);
    } else {
        return \unserialize($val);
    }
}

 private function _unserialize($data)
 {
     if ($this->_has_igbinary) {
         return igbinary_unserialize($data);
     } else {
         return unserialize($data);
     }
 }

 /**
  * @return array
  */
 public static function ADecode($sData)
 {
     $ret = igbinary_unserialize($sData);
     if (null === $ret) {
         return false;
     }
     return $ret;
 }

 protected function convert($input)
 {
     if (function_exists('igbinary_unserialize')) {
         $result = igbinary_unserialize($input);
     } else {
         $result = array();
     }
     return $result;
 }

 /**
  * unserialize
  *
  * @param string $value
  *
  * @return mixed
  */
 public function unserialize($value)
 {
     if (function_exists('igbinary_unserialize')) {
         return igbinary_unserialize($value);
     } else {
         // fallback
         return unserialize($value);
     }
 }

 /**
  * Deserialize igbinary string to PHP value
  *
  * @param  string|binary $serialized
  * @param  array $opts
  * @return mixed
  * @throws Zend_Serializer_Exception on igbinary error
  */
 public function unserialize($serialized, array $opts = array())
 {
     $ret = igbinary_unserialize($serialized);
     if ($ret === null && $serialized !== self::$_serializedNull) {
         $lastErr = error_get_last();
         throw new Zend_Serializer_Exception($lastErr['message']);
     }
     return $ret;
 }

 /**
  * 解密
  * @param $data 加密后的字符串；
  * @return bool|mixed|string 返回加密前的数据类型。
  */
 public function decrypt($data)
 {
     if (empty($data)) {
         return '';
     }
     $data = explode('?', $data)[0];
     $data = base64_decode(str_pad(strtr($data, '-_', '+/'), strlen($data) % 4, '=', STR_PAD_RIGHT));
     $data = Yii::$app->getSecurity()->decryptByKey($data, self::$_key);
     return igbinary_unserialize($data);
 }

function test_speed_unserialize_igbinary($data, $loops)
{
    $serdata = igbinary_serialize($data);
    $start = microtime(true);
    for ($i = 0; $i < $loops; ++$i) {
        $tmp = igbinary_unserialize($serdata);
    }
    $end = microtime(true);
    return $end - $start;
}

 /**
  * Deserialize igbinary string to PHP value
  *
  * @param  string|binary $serialized
  * @param  array $opts
  * @return mixed
  * @throws Zend_Serializer_Exception on igbinary error
  */
 public function unserialize($serialized, array $opts = array())
 {
     $ret = igbinary_unserialize($serialized);
     if ($ret === null && $serialized !== self::$_serializedNull) {
         $lastErr = error_get_last();
         require_once PHP_LIBRARY_PATH . 'Zend/Serializer/Exception.php';
         throw new Zend_Serializer_Exception($lastErr['message']);
     }
     return $ret;
 }

 /**
  * Deserialize igbinary string to PHP value
  *
  * @param  string $serialized
  * @return mixed
  * @throws Exception\RuntimeException on igbinary error
  */
 public function unserialize($serialized)
 {
     if ($serialized === static::$serializedNull) {
         return null;
     }
     ErrorHandler::start();
     $ret = igbinary_unserialize($serialized);
     $err = ErrorHandler::stop();
     if ($ret === null) {
         throw new Exception\RuntimeException('Unserialization failed', 0, $err);
     }
     return $ret;
 }

 public static function unpack($input_string)
 {
     $mark_length = strlen(self::PACKED_MARK);
     if (substr($input_string, 0, $mark_length) != self::PACKED_MARK) {
         return $input_string;
     }
     $string = substr($input_string, $mark_length);
     $string = base64_decode($string);
     if (empty($string)) {
         return $input_string;
     }
     if (function_exists("igbinary_unserialize")) {
         return igbinary_unserialize($string);
     } else {
         return unserialize($string);
     }
 }

    public function __construct($serializable=false)
    {/*{{{*/
        $this->_beginTime = microtime(true);
        $inputs = array_merge($_GET, $_POST);
        if ($serializable)
        {
            //error_log(print_r($inputs, true), 3, '/tmp/a'); 
            $params = igbinary_unserialize(rawurldecode($inputs['data']));
            //error_log(print_r('===='.$params, true), 3, '/tmp/a'); 
            $this->args = $params['args'];
            $this->options = $params['options'];

            //$this->args = unserialize($inputs['data']);
            //$this->options = unserialize($inputs['options']);
            $this->service = $inputs['service'];
            $this->do = $inputs['do'];
        }
    }/*}}}*/

 /**
  * Get cell at a specific coordinate
  *
  * @param  string             $pCoord Coordinate of the cell
  * @throws PHPExcel_Exception
  * @return PHPExcel_Cell      Cell that was found, or null if not found
  */
 public function getCacheData($pCoord)
 {
     if ($pCoord === $this->currentObjectID) {
         return $this->currentObject;
     }
     $this->storeData();
     //    Check if the entry that has been requested actually exists
     if (!isset($this->cellCache[$pCoord])) {
         //    Return null if requested entry doesn't exist in cache
         return null;
     }
     //    Set current entry to the requested entry
     $this->currentObjectID = $pCoord;
     $this->currentObject = igbinary_unserialize($this->cellCache[$pCoord]);
     //    Re-attach this as the cell's parent
     $this->currentObject->attach($this);
     //    Return requested entry
     return $this->currentObject;
 }