PHP gzcompress函数代码示例

 public static function Save($strFormState, $blnBackButtonFlag)
 {
     // Compress (if available)
     if (function_exists('gzcompress')) {
         $strFormState = gzcompress($strFormState, 9);
     }
     // Setup CurrentStateIndex (if none yet exists)
     if (!array_key_exists('qform_current_state_index', $_SESSION)) {
         $_SESSION['qform_current_state_index'] = 0;
     }
     // Increment CurrentStateIndex if BackButtonFlag is true
     // Otherwise, we're in an ajax-to-ajax call, and the back button is invalid anyway
     // No need to increment session state index -- let's not to save space
     //			if ($blnBackButtonFlag)
     $_SESSION['qform_current_state_index'] = $_SESSION['qform_current_state_index'] + 1;
     $intStateIndex = $_SESSION['qform_current_state_index'];
     // Save THIS formstate
     // NOTE: if gzcompress is used, we are saving the *BINARY* data stream of the compressed formstate
     // In theory, this SHOULD work.  But if there is a webserver/os/php version that doesn't like
     // binary session streams, you can first base64_encode before saving to session (see note below).
     $_SESSION['qform_' . $intStateIndex] = $strFormState;
     // Return StateIndex
     if (!is_null(QForm::$EncryptionKey)) {
         // Use QCryptography to Encrypt
         $objCrypto = new QCryptography(QForm::$EncryptionKey, true);
         return $objCrypto->Encrypt($intStateIndex);
     } else {
         return $intStateIndex;
     }
 }

function compress($data, $compressed)
{
    if ($compressed == 1) {
        return gzcompress($data);
    }
    return $data;
}

 /**
  * 写入缓存
  * @param string $name 缓存文件名字
  * @param function $callback 回调函数，必须要有返回值
  * @param Array or string or Object $params 要传进去的参数
  * @param int $time 写入的缓存时间
  * @return array
  * @author wave
  */
 public static function wirte($name, $callback, $params = null, $time = TIME)
 {
     self::init();
     $file = ROOT . DS . APP_PATH . DS . self::$cache_dir;
     $content = '';
     if (!file_exists($file . self::CACHE_PREFIX . $name)) {
         $content = $callback($params);
         if (!empty($content)) {
             file_put_contents($file . self::CACHE_PREFIX . $name, gzcompress(serialize($content)));
             return;
         }
     }
     if (empty($time)) {
         return;
     }
     if (file_exists($file . self::CACHE_PREFIX . $name)) {
         $cache_time = strtotime(date('Y-m-d H:i:s')) - strtotime(date('Y-m-d H:i:s', filemtime($file . self::CACHE_PREFIX . $name)));
         if ($cache_time / 1000 >= $time || $time == 1) {
             $content = $callback($params);
             if (!empty($content)) {
                 file_put_contents($file . self::CACHE_PREFIX . $name, gzcompress(serialize($content)));
                 return;
             }
         }
     }
 }

 /**
  * 写入缓存
  * @access public
  * @param string $name 缓存变量名
  * @param mixed $value  存储数据
  * @param int $expire  有效时间 0为永久
  * @return boolean
  */
 public function set($name, $value, $expire = null)
 {
     if (is_null($expire)) {
         $expire = $this->options['expire'];
     }
     $filename = $this->getFileName($name);
     $data = serialize($value);
     //是否数据压缩
     if ($this->options['compress'] && function_exists('gzcompress')) {
         //数据压缩
         $data = gzcompress($data, 3);
     }
     //是否数据校验
     if ($this->options['check']) {
         $check = md5($data);
     } else {
         $check = '';
     }
     $data = "<?php\n//" . sprintf('%012d', $expire) . $check . $data . "\n?>";
     $result = file_put_contents($filename, $data);
     if ($result) {
         //            if($this->options['length']>0) {
         //                // 记录缓存队列
         //                $this->queue($name);
         //            }
         clearstatcache();
         return true;
     } else {
         return false;
     }
 }

function save_array_dump($filename, $array)
{
    $dump = addslashes(gzcompress(var_export($array, true), 9));
    $fp = fopen($filename, "wb+");
    fwrite($fp, $dump);
    fclose($fp);
}

 function secure_serialize($data)
 {
     $mainframe =& JFactory::getApplication();
     $secret = $mainframe->getCfg('secret');
     $sData = strtr(base64_encode(addslashes(gzcompress(serialize($data), 9))), '+/=', '-_,');
     return sha1($sData . $secret) . $sData;
 }

 function print_gzipped_page()
 {
     $HTTP_ACCEPT_ENCODING = getenv("HTTP_ACCEPT_ENCODING");
     if (headers_sent()) {
         $encoding = false;
     } elseif (strpos($HTTP_ACCEPT_ENCODING, 'x-gzip') !== false) {
         $encoding = 'x-gzip';
     } elseif (strpos($HTTP_ACCEPT_ENCODING, 'gzip') !== false) {
         $encoding = 'gzip';
     } else {
         $encoding = false;
     }
     if ($encoding) {
         $contents = ob_get_contents();
         ob_end_clean();
         header('Content-Encoding: ' . $encoding);
         header("ETag: " . md5($contents));
         // ETag im Header senden
         header("Expires: " . date("r", mktime(0, 0, 0, date("n"), date("j") + 365)));
         print "�";
         $size = strlen($contents);
         $contents = gzcompress($contents, 9);
         $contents = substr($contents, 0, $size);
         print $contents;
         //             exit();
     } else {
         ob_end_flush();
         //             exit();
     }
 }

 /**
  * Sends a command to the server and returns an object with the result 
  * 
  * @param string $cmd               Protocol command to be executed
  * @param string $message           Full email message
  * @param array  $additionalHeaders Associative array with additional headers
  */
 protected function exec($cmd, $message, array $additionalHeaders = array())
 {
     $socket = $this->getSocket();
     $message .= "\r\n";
     $contentLength = strlen($message);
     if (!empty($this->maxSize)) {
         if ($contentLength > $this->maxSize) {
             throw new Exception("Message exceeds the maximum allowed size of {$this->maxSize} kbytes");
         }
     }
     $cmd = $cmd . ' SPAMC/' . $this->protocolVersion . "\r\n";
     $cmd .= "Content-length: {$contentLength}\r\n";
     if ($this->enableZlib && function_exists('gzcompress')) {
         $cmd .= "Compress: zlib\r\n";
         $message = gzcompress($message);
     }
     if (!empty($this->user)) {
         $cmd .= 'User: ' . $this->user . "\r\n";
     }
     if (!empty($additionalHeaders)) {
         foreach ($additionalHeaders as $headerName => $val) {
             $cmd .= $headerName . ': ' . $val . "\r\n";
         }
     }
     $cmd .= "\r\n";
     $cmd .= $message;
     $cmd .= "\r\n";
     $this->write($socket, $cmd);
     list($headers, $message) = $this->read($socket);
     return $this->parseOutput($headers, $message);
 }

 function compile($compressionLevel = 0)
 {
     $this->header->setCompressed($compressionLevel > 0);
     $data = '';
     foreach ($this->tags as $tag) {
         $data .= $tag->getTagContent();
     }
     $header = $this->header->getPacked();
     $len = strlen($header) + strlen($data);
     $this->header->filelength->set($len);
     $data = $this->header->getPacked() . $data;
     if ($compressionLevel > 0) {
         $compressionStartTime = $this->microtime_float();
         // The first eight bytes are uncompressed
         $uncompressedBytes = substr($data, 0, 8);
         // Remove first eight bytes
         $data = substr_replace($data, '', 0, 8);
         // Compress the rest of the SWF
         $data = gzcompress($data, $compressionLevel);
         // Add the uncompressed header
         $data = $uncompressedBytes . $data;
         $compressionDuration = $this->microtime_float() - $compressionStartTime;
         if (LOG_ALL) {
             error_log('[SWX] PROFILING: SWF compression took ' . $compressionDuration . ' seconds.');
         }
         // Stats
         $compressedSize = strlen($data);
         if (LOG_ALL) {
             error_log('[SWX] INFO Compressed size of SWF: ' . $compressedSize . ' bytes.');
         }
     }
     $this->data = $data;
 }

 /**
  * Forwards the logging event to the Graylog2 server.
  * @param LoggerLoggingEvent $event
  */
 protected function append(LoggerLoggingEvent $event)
 {
     $message = gzcompress($this->layout->format($event));
     $socket = $this->getSocketConnection();
     if (strlen($message) > $this->getChunkSize()) {
         // A unique id which consists of the microtime and a random value
         $messageId = uniqid();
         // Split the message into chunks
         $messageChunks = str_split($message, $this->getChunkSize());
         $messageChunksCount = count($messageChunks);
         // Send chunks to graylog server
         foreach ($messageChunks as $messageChunkIndex => $messageChunk) {
             $bytesWritten = $this->writeMessageChunkToSocket($socket, $messageId, $messageChunk, $messageChunkIndex, $messageChunksCount);
             if (false === $bytesWritten) {
                 // Abort due to write error
                 return false;
             }
         }
     } else {
         // A single write is enough to get the message published
         if (false === $this->writeMessageToSocket($socket, $message)) {
             // Abort due to write error
             return false;
         }
     }
 }

 public function set($key, $value, $expire = '')
 {
     $freeSpace = disk_free_space($this->config['path']);
     $freeSpaceMB = $freeSpace ? floor($freeSpace / 1024 / 1024) : 0;
     if ($freeSpaceMB < 10) {
         Axion_log::getinstance()->newMessage('磁盘容量过小，无法存储数据缓存文件', AXION_LOG::WARNING);
         return false;
     }
     $hash = md5($key);
     $expire = $expire ? $expire : $this->config['expire'];
     $expire = sprintf('%09d', $expire);
     $data = serialize($value);
     self::$_data[$hash] = $data;
     if (!is_dir($this->config['path'])) {
         if (!AXION_UTIL_FILE::mkdir($this->config['path'])) {
             throw new AXION_EXCEPTION('无法创建Cache文件目录:' . $this->config['path']);
         }
     }
     $fileName = $this->genFileName($key);
     if (IS_SHM && function_exists('gzcompress')) {
         $data = gzcompress($data, 4);
     }
     $data = $expire . $data;
     $result = file_put_contents($fileName, $data);
     if ($result) {
         clearstatcache();
         return true;
     } else {
         return false;
     }
 }

 public static function save($label, $data, $expires = null, $compress = true)
 {
     $label = urlencode($label);
     $dir = rtrim(self::$dir, "/");
     if (is_object($data) || is_array($data)) {
         if (method_exists($data, "__toString")) {
             $data = call_user_func(array($data, '__toString'));
         } else {
             $data = serialize($data);
         }
     }
     $str = (string) gzcompress($data);
     if (strlen($str) > $data) {
         $str = $data;
     }
     if ((bool) file_put_contents("{$dir}/{$label}", $str)) {
         if ($expires) {
             $expires = time() + (int) $expires;
         } else {
             $expires = time() + 60 * 60 * 24 * 365 * 10;
         }
         touch("{$dir}/{$label}", time(), $expires);
         return $data;
     } else {
         throw new Exception("Could not cache file.", 0);
     }
 }

 protected function encode($value = null)
 {
     if (!$value) {
         return '';
     }
     return base64_encode(gzcompress(serialize($value)));
 }

function ncd_new($sx, $sy, $prec = 0, $MAXLEN = 9000)
{
    # NCD with gzip artifact correctoin and percentual return.
    # sx,sy = strings to compare.
    # Use $prec=-1 for result range [0-1], $pres=0 for percentual,
    # For NCD definition see http://arxiv.org/abs/0809.2553
    $x = $min = strlen(gzcompress($sx));
    $y = $max = strlen(gzcompress($sy));
    $xy = strlen(gzcompress($sx . $sy));
    $a = $sx;
    if ($x > $y) {
        # swap min/max
        $min = $y;
        $max = $x;
        $a = $sy;
    }
    $res = ($xy - $min) / $max;
    # NCD definition.
    #Little strings):
    if ($MAXLEN < 0 || $xy < $MAXLEN) {
        $aa = strlen(gzcompress($a . $a));
        $ref = ($aa - $min) / $min;
        $res = $res - $ref;
        # correction
    }
    return $prec < 0 ? $res : 100 * round($res, 2 + $prec);
}

 public static function serialize($data, $type)
 {
     $types = explode('|', $type, 2);
     switch ($types[0]) {
         case self::SERIALIZE_TYPE_BASE64:
             if (!empty($types[1])) {
                 $data = self::serialize($data, $types[1]);
             }
             return self::SERIALIZE_TYPE_BASE64 . ' ' . base64_encode($data);
         case self::SERIALIZE_TYPE_GZIP:
             if (!empty($types[1])) {
                 $data = self::serialize($data, $types[1]);
             }
             if (strlen($data) < self::GZIP_MIN_LENGTH) {
                 return $data;
             }
             return self::SERIALIZE_TYPE_GZIP . ' ' . gzcompress($data);
         case self::SERIALIZE_TYPE_PHP_SERIALIZE:
             return self::SERIALIZE_TYPE_PHP_SERIALIZE . ' ' . serialize($data);
         case self::SERIALIZE_TYPE_JSON:
             return self::SERIALIZE_TYPE_JSON . ' ' . json_encode($data);
         default:
             throw new InvalidArgumentException();
     }
 }