PHP Zend_Cache_Core::save方法代码示例

 public static function find($search_data, array $overrideSources = null)
 {
     $sources = array('local', 'def');
     if (is_array($overrideSources)) {
         $sources = $overrideSources;
     }
     if (self::$_cache !== null && is_scalar($search_data) && is_numeric($search_data)) {
         $cached = self::$_cache->load(__CLASS__ . implode('_', $sources) . $search_data);
         if ($cached !== false) {
             return $cached;
         }
     }
     $found = array();
     foreach ($sources as $source) {
         $sourceObject = self::getSource($source);
         $founded_temp = self::findInSource($search_data, is_array($search_data) ? self::detectCustomerType($search_data) : '', $sourceObject);
         if (count($founded_temp) > 0) {
             $found = array_merge($found, $founded_temp);
         }
     }
     if (self::$_cache !== null && is_scalar($search_data) && count($found) == 1 && is_numeric($search_data)) {
         self::$_cache->save($found, __CLASS__ . implode('_', $sources) . $search_data);
     }
     return $found;
 }

 /**
  * Save the cache here
  */
 public function __destruct()
 {
     // \MUtil_Echo::track(count($this->_commands));
     if ($this->_commands) {
         $this->_cache->save($this->_commands, $this->_cacheId, array('batch', 'sess_' . session_id()));
     } else {
         $this->_cache->remove($this->_cacheId);
     }
 }

 /**
  * 
  */
 public function alternative($alternative_id, Model_Alternative $modelAlternative)
 {
     $nameCache = 'alternative_' . $alternative_id;
     $alternative = $this->cache->load($nameCache);
     $origem = "--->alternative vem do cache---";
     //recupera do cache
     if ($alternative == false) {
         $alternative = $modelAlternative->getAlternativeById($alternative_id);
         $this->cache->save($alternative, $nameCache);
         $origem = "--->alternative NAO vem do cache---";
     }
     return $alternative;
 }

 public function testSave()
 {
     $reply = $this->cache->save('aaa', 'test');
     $this->assertTrue($reply);
     $value = $this->rediska->get('test');
     $this->assertTrue(is_array($value));
     $this->assertEquals('aaa', $value[0]);
     $reply = $this->cache->save('aaa', 'test', array(), 2);
     $this->assertTrue($reply);
     sleep(3);
     $value = $this->rediska->get('test');
     $this->assertNull($value);
 }

 /**
  * metodo chamado em Vtx_Plugin_Permission
  */
 public function fazCacheAcl($sysId = 1)
 {
     if ($sysId == 1) {
         $nameCache = 'acl';
     } else {
         $nameCache = 'acl' . $sysId;
     }
     $acl = $this->cache->load($nameCache);
     if (!$acl) {
         $acl = new Model_Acl(true);
         $this->cache->save($acl, $nameCache);
     }
     return $acl;
 }

 /**
  * get by id
  * - results are cached
  *
  * @param string $_id the id of the peer
  * @return Voipmanager_Model_Snom_Location
  */
 public function get($_id)
 {
     $id = Tinebase_Record_Abstract::convertId($_id, $this->_modelName);
     if ($this->_cacheIdPrefix && $this->_cache) {
         $cacheId = $this->_cacheIdPrefix . $id;
         if ($this->_cache->test($id)) {
             $result = $this->_cache->load($id);
         } else {
             $result = $this->_backend->get($id);
             $this->_cache->save($result, $cacheId, array($this->_cacheIdPrefix), 5);
         }
     } else {
         $result = $this->_backend->get($id);
     }
     return $result;
 }

 /**
  * Internal function for adding translation data
  *
  * It may be a new language or additional data for existing language
  * If $clear parameter is true, then translation data for specified
  * language is replaced and added otherwise
  *
  * @see    Zend_Locale
  * @param  array|string       $data    Translation data
  * @param  string|Zend_Locale $locale  Locale/Language to add data for, identical with locale identifier,
  *                                     @see Zend_Locale for more information
  * @param  array              $options (optional) Option for this Adapter
  * @throws Zend_Translate_Exception
  * @return Zend_Translate_Adapter Provides a fluid interface
  */
 private function _addTranslationData($data, $locale, array $options = array())
 {
     if (!($locale = Zend_Locale::isLocale($locale))) {
         /**
          * @see Zend_Translate_Exception
          */
         require_once 'Zend/Translate/Exception.php';
         throw new Zend_Translate_Exception("The given Language ({$locale}) does not exist");
     }
     if (!array_key_exists($locale, $this->_translate)) {
         $this->_translate[$locale] = array();
     }
     $this->_loadTranslationData($data, $locale, $options);
     if ($this->_automatic === true) {
         $find = new Zend_Locale($locale);
         $browser = $find->getBrowser() + $find->getEnvironment();
         arsort($browser);
         foreach ($browser as $language => $quality) {
             if (array_key_exists($language, $this->_translate)) {
                 $this->_options['locale'] = $language;
                 break;
             }
         }
     }
     if (isset(self::$_cache)) {
         $id = 'Zend_Translate_' . $this->toString();
         $temp = $this->_translate;
         $temp['_options_'] = $this->_options;
         self::$_cache->save(serialize($temp), $id);
     }
     return $this;
 }

 protected function setKeys()
 {
     $this->cache->save('aaa', 'test_aaa', array('tag_a1'));
     $this->cache->save('bbb', 'test_bbb', array('tag_a1', 'tag_a2'));
     $this->cache->save('ccc', 'test_ccc', array('tag_a2'));
     $this->cache->save('ddd', 'test_ddd', array('tag_a3'));
 }

 /**
  * Replace one found esi include with a given url
  *
  * @param string $url
  * @return string|null
  */
 protected function _replaceEsiInclude($url)
 {
     $uri = 'http://' . $_SERVER['HTTP_HOST'] . $url;
     $key = $this->_getCacheId($uri);
     if ($this->_cacheEnabled()) {
         // detect if url is cached
         $data = self::$_cache->load($key);
         if (false !== $data) {
             return $data;
         }
     }
     $fp = fopen($uri, 'r', false, $this->_getHttpContext());
     if (false !== $fp) {
         $data = stream_get_contents($fp);
         if ($this->_cacheEnabled()) {
             $meta = stream_get_meta_data($fp);
             // fetch the metadata of the fopen call
             foreach ($meta['wrapper_data'] as $header) {
                 $match = array();
                 if (preg_match(self::ESI_CACHE_REGEX, $header, $match)) {
                     if (false !== $data) {
                         // cache url with the respected max-age setting
                         self::$_cache->save($data, $key, array(), intval($match[1]));
                         break;
                     }
                 }
             }
         }
         fclose($fp);
         return $data;
     }
     return null;
 }

 /**
  * Recupera parser do Pdf: faz o parser em tempo real ou recupera do cache
  * 
  * @param string $arqInsert
  * @return fpdi_pdf_parser
  */
 public function cacheOrParserPdfWithFPDI($pagePdf, $pathArquivoPdf)
 {
     //try {
     //verifica parser do Pdf no cache
     $parserPdfCache = $this->cache->load($pagePdf);
     $origem = "--->parserPdf vem do cache---";
     $this->objMakePdf->current_filename = $pathArquivoPdf;
     //recupera do cache
     if ($parserPdfCache == false) {
         //tento fazer o parser do pdf
         $parserPdfCache = $this->objMakePdf->_getPdfParser($pathArquivoPdf);
         //salvo o parser do pdf no cache
         $this->cache->save($parserPdfCache, $pagePdf);
         $origem = "--->parserPdf NAO vem do cache---";
     } else {
         //grava parser pdf no var do objeto FPDI
         $this->objMakePdf->parsers[$pathArquivoPdf] = $parserPdfCache;
     }
     echo $origem;
     $this->setCacheYesOrNo($origem);
     $result = true;
     //} catch (Exception $e) {
     //    throw new Exception("There is a problem at PDF parser process");
     //    $result = false;
     // }
     return $result;
 }

 protected function _loadConfig($file)
 {
     if ($this->_useCache == false) {
         return parent::_loadConfig($file);
     }
     $configMTime = filemtime($file);
     $cacheId = "application_conf_" . md5($file . $this->getEnvironment());
     $cacheLastMTime = $this->_configCache->test($cacheId);
     //Valid cache?
     if ($cacheLastMTime !== false && $configMTime <= $cacheLastMTime) {
         return $this->_configCache->load($cacheId, true);
     }
     $config = parent::_loadConfig($file);
     $this->_configCache->save($config, $cacheId, array(), null);
     return $config;
 }

 /**
  * Save in cache
  *
  * @return void
  */
 private function _saveInCache(Zend_Cache_Core $cache)
 {
     $cacheData = array();
     $cacheData['tableName'] = $this->_dbData->getTable()->getComponentName();
     $cacheData['dataArray'] = $this->_dbData->toArray(self::SERIALIZATION_DEEP);
     $cache->save($cacheData, $this->_cacheKey);
 }

 public function getHistorical($name, $date)
 {
     $sufix = str_replace('-', '', substr($date, 0, 10));
     $cached = $this->_cache->load(__CLASS__ . $name . $sufix);
     if ($cached !== false) {
         return $cached;
     } else {
         $row = $this->fetchRow(array('key = ?' => $name, 'created_at::date <= \'' . $date . '\'::date'), 'id DESC');
         if ($row !== null) {
             $this->_cache->save($row->value, __CLASS__ . $name . $sufix);
             return $row->value;
         } else {
             return $this->get($name);
         }
     }
 }

 /**
  * Utility function for loading a query from cache
  *
  * @param string $cacheId The class is prepended to this id
  * @param mixed $sql string or \Zend_Db_Select
  * @param callable $function The function called with each row to form the result
  * @param string $keyField The field containing the key for each row
  * @param mixed $tags string or array of strings
  * @param string Optional function to sort on, only known functions will do
  * @return array
  */
 protected function _getSelectProcessedCached($cacheId, $sql, $function, $keyField, $tags = array(), $sort = null)
 {
     $cacheId = get_class($this) . '_' . $cacheId;
     $result = false;
     //$this->cache->load($cacheId);
     if ($result) {
         return $result;
     }
     $result = array();
     try {
         $rows = $this->db->fetchAll($sql);
         if ($rows) {
             foreach ($rows as $row) {
                 if (!isset($result[$row[$keyField]])) {
                     $result[$row[$keyField]] = call_user_func($function, $row);
                 }
             }
             if ($sort) {
                 $this->_sortResult($result, $sort);
             }
         }
         $this->cache->save($result, $cacheId, (array) $tags);
     } catch (\Zend_Db_Statement_Mysqli_Exception $e) {
     }
     return $result;
 }

 /**
  * Perform a raw query against the search index, returning a SolrResultSet object that 
  * can be used to extract a more complete result set
  *
  * @param String $query
  * 			The lucene query to execute.
  * @param int $page
  * 			What result page are we on?
  * @param int $limit
  * 			How many items to limit the query to return
  * @param array $params
  * 			A set of parameters to be passed along with the query
  * @param array $andWith
  *			A set of extra and with terms to add to the query
  * @return SolrResultSet
  */
 public function query($query, $offset = 0, $limit = 20, $params = array(), $andWith = array())
 {
     if (is_string($query)) {
         $builder = $this->getQueryBuilder('default');
         $builder->baseQuery($query);
         $query = $builder;
     }
     // be very specific about the subsite support :).
     if (ClassInfo::exists('Subsite')) {
         $query->andWith('SubsiteID_i', Subsite::currentSubsiteID());
     }
     // add the stage details in - we should probably use an extension mechanism for this,
     // but for now this will have to do. @TODO Refactor this....
     $stage = Versioned::current_stage();
     if (!$stage && !(isset($params['ignore_stage']) && $params['ignore_stage'])) {
         // default to searching live content only
         $stage = 'Live';
     }
     if (!isset($params['ignore_stage']) || !$params['ignore_stage']) {
         $query->andWith('SS_Stage_ms', $stage);
     }
     if ($andWith) {
         foreach ($andWith as $field => $value) {
             $query->andWith($field, $value);
         }
     }
     $extraParams = $query->getParams();
     $params = array_merge($params, $extraParams);
     $query = $query->toString();
     $response = null;
     $rawResponse = null;
     $solr = $this->getSolr();
     $key = null;
     if ($this->cache) {
         $key = md5($query . $offset . $limit . serialize($params));
         if ($rawResponse = $this->cache->load($key)) {
             $response = new Apache_Solr_Response($rawResponse, array('HTTP/1.1 200 OK', 'Content-Type: text/plain; charset=utf-8'), $solr->getCreateDocuments(), $solr->getCollapseSingleValueArrays());
         }
     }
     if (!$response) {
         // Execute the query and log any errors on failure, always displaying the search results to the user.
         if ($this->isConnected()) {
             try {
                 $response = $this->getSolr()->search($query, $offset, $limit, $params);
             } catch (Exception $e) {
                 SS_Log::log($e, SS_Log::NOTICE);
             }
         }
     }
     $queryParams = new stdClass();
     $queryParams->offset = $offset;
     $queryParams->limit = $limit;
     $queryParams->params = $params;
     $results = new SolrResultSet($query, $response, $queryParams, $this);
     if ($this->cache && !$rawResponse && $key && $response) {
         $this->cache->save($response->getRawResponse(), $key, array(), $this->cacheTime);
     }
     return $results;
 }