A class to manage the caching of html outputs and data structures
<?php | |
/** | |
* @file cache.php | |
* @brief Contains the \ref cache, outputCache and dataCache classes. | |
* | |
* @author abidibo abidibo@gmail.com | |
* @version 0.99 | |
* @date 2011-2012 | |
* @copyright Otto srl [MIT License](http://www.opensource.org/licenses/mit-license.php) | |
*/ | |
/** | |
* @defgroup cache Outputs and data caching | |
* Library to store outputs (text, html, xml) and data structures writing to file | |
*/ | |
/** | |
* @ingroup cache | |
* @brief cache super class | |
* | |
* Provides methods to handle file operations. | |
* | |
* @author abidibo abidibo@gmail.com | |
* @version 0.99 | |
* @date 2011-2012 | |
* @copyright Otto srl [MIT License](http://www.opensource.org/licenses/mit-license.php) | |
*/ | |
class cache { | |
/** | |
* @brief directory separator | |
*/ | |
protected $_ds; | |
/** | |
* @brief absolute path to the cache folder storing all the cache files | |
*/ | |
protected $_fld; | |
/** | |
* @brief cache files prefix | |
*/ | |
protected $_prefix; | |
/** | |
* @brief cache content group | |
*/ | |
protected $_grp; | |
/** | |
* @brief cache content identifier | |
*/ | |
protected $id; | |
/** | |
* @brief caching time | |
*/ | |
protected $_tc; | |
/** | |
* @brief status | |
*/ | |
protected $_enabled; | |
/** | |
* @brief Construct a cache instance | |
* | |
* @return cache instance | |
*/ | |
function __construct() { | |
$this->_ds = DS; | |
$this->_fld = ABS_CACHE; | |
$this->_prefix = 'cache_'; | |
$this->_enabled = true; | |
} | |
/** | |
* @brief Writes data to file | |
* | |
* @param string $data | |
* @return void | |
*/ | |
protected function write($data) { | |
$filename = $this->getFilename(); | |
if($fp = @fopen($filename, "xb")) { | |
if(flock($fp, LOCK_EX)) fwrite($fp, $data); | |
fclose($fp); | |
touch($filename, time()); | |
} | |
} | |
/** | |
* @brief Reads data from file | |
* | |
* @return data in string format | |
*/ | |
protected function read() { | |
return file_get_contents($this->getFilename()); | |
} | |
/** | |
* @brief Gets the cached filename | |
* | |
* @return the filename | |
*/ | |
protected function getFilename() { | |
return $this->_fld . $this->_ds . $this->_prefix . $this->_grp ."_". md5($this->_id); | |
} | |
/** | |
* @brief Cheks if data are cached and not expired | |
* | |
* @return true if data are cached and the cache time is not expired, false otherwise | |
*/ | |
protected function isCached() { | |
$filename = $this->getFilename(); | |
if($this->_enabled && file_exists($filename) && time() < (filemtime($filename) + $this->_tc)) return true; | |
else @unlink($filename); | |
return false; | |
} | |
} | |
/** | |
* @ingroup cache | |
* @brief Cache implemetation to store html/text/xml outputs | |
* | |
* ### Usage | |
* | |
* ~~~~~~~~~~~~~~~~~~~{.php} | |
* $buffer = "previous text-"; | |
* $cache = new outputCache($buffer); | |
* if($cache->start("group_name", "id", 3600)) { | |
* | |
* $cache_buffer = "some content-"; | |
* | |
* $cache->stop($cache_buffer); | |
* | |
* } | |
* $buffer .= "next text"; | |
* ~~~~~~~~~~~~~~~~~~~ | |
* | |
* the result is: | |
* ~~~~~~~~~~~~~~~~~~~{.php} | |
* $buffer = "previous text-somec content-next text"; | |
* ~~~~~~~~~~~~~~~~~~~ | |
* | |
* if the content is cached the if statement is skipped and the content is | |
* concatenated to $buffer, | |
* if content is not cached the if statemet runs, the content is prepared | |
* and then saved in cache and added to $buffer (through stop method) | |
* | |
* @author abidibo abidibo@gmail.com | |
* @version 0.99 | |
* @date 2011-2012 | |
* @copyright Otto srl [MIT License](http://www.opensource.org/licenses/mit-license.php) | |
*/ | |
class outputCache extends cache { | |
/** | |
* @brief reference to the output to which add the cached data | |
*/ | |
protected $_buffer; | |
/** | |
* @brief Constructs a outputCache instance | |
* | |
* @param mixed &$buffer reference to the $_buffer variable | |
* @param mixed $enable status | |
* @return outputCache instance | |
*/ | |
function __construct(&$buffer, $enable = true) { | |
parent::__construct(); | |
$this->_buffer = &$buffer; | |
$this->_enabled = $enable; | |
} | |
/** | |
* @brief Starts the caching process | |
* | |
* If data are cached and not expired adds data to the $_buffer member and returns false, else returns true. | |
* | |
* @param string $grp the output data group | |
* @param mixed $id the output data identifier | |
* @param mixed $tc the caching time | |
* @return false if data are already cached and not expired, true otherwise | |
*/ | |
public function start($grp, $id, $tc) { | |
$this->_grp = $grp; | |
$this->_id = $id; | |
$this->_tc = $tc; | |
if($this->isCached()) { | |
$this->_buffer .= $this->read(); | |
return false; | |
} | |
return true; | |
} | |
/** | |
* @brief Stops the caching process | |
* | |
* Writes data to file and adds it to the $_buffer member. | |
* | |
* @param string $data the output data | |
* @return void | |
*/ | |
public function stop($data) { | |
if($this->_enabled) $this->write($data); | |
$this->_buffer .= $data; | |
} | |
} | |
/** | |
* @ingroup cache | |
* @brief Cache implementation to store data structures | |
* | |
* ### Usage | |
* | |
* ~~~~~~~~~~~~~~~~~~~{.php} | |
* $cache = new dataCache(); | |
* if(!$data = $cache->get('group_name', 'id', 3600)) { | |
* | |
* $data = someCalculations(); | |
* $cache->save($data); | |
* | |
*} | |
* ~~~~~~~~~~~~~~~~~~~ | |
* | |
* if data is stored it's returned by get method and if statement is not processed, otherwise data | |
* is calculated and saved in cache | |
* | |
* @author abidibo abidibo@gmail.com | |
* @version 0.99 | |
* @date 2011-2012 | |
* @copyright Otto srl [MIT License](http://www.opensource.org/licenses/mit-license.php) | |
*/ | |
class dataCache extends cache { | |
/** | |
* @brief Constructs a dataCache instance | |
* | |
* @param mixed $enable status | |
* @return dataCache instance | |
*/ | |
function __construct($enable = true) { | |
parent::__construct(); | |
$this->_enabled = $enable; | |
} | |
/** | |
* @brief Tries to retrieve cached data | |
* | |
* If data are cached and not expired returns them, else returns false. | |
* | |
* @param string $grp the output data group | |
* @param mixed $id the output data identifier | |
* @param mixed $tc the caching time | |
* @return data if are already cached and not expired, false otherwise | |
*/ | |
public function get($grp, $id, $tc) { | |
$this->_grp = $grp; | |
$this->_id = $id; | |
$this->_tc = $tc; | |
if($this->isCached()) return unserialize($this->read()); | |
return false; | |
} | |
/** | |
* @brief Saves data in cache | |
* | |
* @param string $data the data to put in cache | |
* @return void | |
*/ | |
public function save($data) { | |
if($this->_enabled) $this->write(serialize($data)); | |
} | |
} | |
?> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment