/**
* Returns cached content
*
* @param string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, get){
zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key;
zval *cached_content, *processed;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SVV(prefixed_key, "_PHCX", prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cached_content);
phalcon_call_func_p1(cached_content, "xcache_get", prefixed_key);
if (Z_TYPE_P(cached_content) == IS_NULL) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(processed);
phalcon_call_method_p1(processed, frontend, "afterretrieve", cached_content);
RETURN_CCTOR(processed);
}
/**
* Returns cached content
*
* @param string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, get){
zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key;
zval *cached_content = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
frontend = phalcon_read_property(getThis(), SL("_frontend"), PH_NOISY);
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SVV(prefixed_key, "_PHCX", prefix, key_name);
phalcon_update_property_this(getThis(), SL("_lastKey"), prefixed_key);
PHALCON_CALL_FUNCTION(&cached_content, "xcache_get", prefixed_key);
if (Z_TYPE_P(cached_content) == IS_NULL) {
RETURN_MM_NULL();
}
if (phalcon_is_numeric(cached_content)) {
RETURN_CCTOR(cached_content);
} else {
PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content);
}
RETURN_MM();
}
/**
* Decrement of a given key, by number $value
*
* @param string $keyName
* @param long $value
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Apc, decrement){
zval *key_name, *value = NULL, prefix = {}, prefixed_key = {}, cached_content = {};
phalcon_fetch_params(0, 1, 1, &key_name, &value);
if (!value || Z_TYPE_P(value) == IS_NULL) {
value = &PHALCON_GLOBAL(z_one);
} else {
PHALCON_ENSURE_IS_LONG(value);
}
phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY);
PHALCON_CONCAT_SVV(&prefixed_key, "_PHCA", &prefix, key_name);
phalcon_update_property_zval(getThis(), SL("_lastKey"), &prefixed_key);
if (SUCCESS == phalcon_function_exists_ex(SL("apc_dec"))) {
PHALCON_RETURN_CALL_FUNCTIONW("apc_dec", &prefixed_key, value);
} else {
PHALCON_CALL_FUNCTIONW(&cached_content, "apc_fetch", &prefixed_key);
if (Z_TYPE(cached_content) == IS_LONG) {
phalcon_sub_function(return_value, &cached_content, value);
PHALCON_CALL_METHODW(NULL, getThis(), "save", key_name, return_value);
} else {
RETURN_FALSE;
}
}
}
/**
* Reads meta-data from APC
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, read){
zval *key, prefix = {}, apc_key = {};
phalcon_fetch_params(0, 1, 0, &key);
phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY);
PHALCON_CONCAT_SVV(&apc_key, "$PMM$", &prefix, key);
PHALCON_CALL_FUNCTIONW(return_value, "apc_fetch", &apc_key);
}
/**
* Writes the meta-data to APC
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, write){
zval *key, *data, prefix = {}, apc_key = {}, ttl = {};
phalcon_fetch_params(0, 2, 0, &key, &data);
phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY);
PHALCON_CONCAT_SVV(&apc_key, "$PMM$", &prefix, key);
phalcon_read_property(&ttl, getThis(), SL("_ttl"), PH_NOISY);
PHALCON_CALL_FUNCTIONW(NULL, "apc_store", &apc_key, data, &ttl);
}
/**
* Writes the meta-data to APC
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, write){
zval *key, *data, *prefix, *apc_key, *ttl;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(apc_key);
PHALCON_CONCAT_SVV(apc_key, "$PMM$", prefix, key);
ttl = phalcon_read_property(getThis(), SL("_ttl"), PH_NOISY);
PHALCON_CALL_FUNCTION(NULL, "apc_store", apc_key, data, ttl);
PHALCON_MM_RESTORE();
}
/**
* Writes the metadata to XCache
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, write){
zval *key, *data, *prefix, *xc_key, *ttl;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(xc_key);
PHALCON_CONCAT_SVV(xc_key, "$PMM$", prefix, key);
PHALCON_OBS_VAR(ttl);
phalcon_read_property_this(&ttl, this_ptr, SL("_ttl"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "xcache_set", xc_key, data, ttl);
PHALCON_MM_RESTORE();
}
/**
* Reads metadata from XCache
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, read){
zval *key, *prefix, *xc_key, *data = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(xc_key);
PHALCON_CONCAT_SVV(xc_key, "$PMM$", prefix, key);
PHALCON_CALL_FUNCTION(&data, "xcache_get", xc_key);
if (Z_TYPE_P(data) == IS_ARRAY) {
RETURN_CCTOR(data);
}
RETURN_MM_NULL();
}
/**
* Reads meta-data from APC
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, read)
{
zval *key, *prefix, *apc_key, *data = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(apc_key);
PHALCON_CONCAT_SVV(apc_key, "$PMM$", prefix, key);
PHALCON_CALL_FUNCTION(&data, "apc_fetch", apc_key);
if (Z_TYPE_P(data) == IS_ARRAY) {
RETURN_CCTOR(data);
}
RETURN_MM_NULL();
}
/**
* Writes the metadata to XCache
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, write){
zval *key, *data, *prefix, *xc_key, *ttl;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(xc_key);
PHALCON_CONCAT_SVV(xc_key, "$PMM$", prefix, key);
PHALCON_OBS_VAR(ttl);
phalcon_read_property_this(&ttl, this_ptr, SL("_ttl"), PH_NOISY_CC);
phalcon_call_func_p3_noret("xcache_set", xc_key, data, ttl);
PHALCON_MM_RESTORE();
}
/**
* Reads metadata from XCache
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, read){
zval *key, *prefix, *xc_key, *data;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(xc_key);
PHALCON_CONCAT_SVV(xc_key, "$PMM$", prefix, key);
PHALCON_INIT_VAR(data);
phalcon_call_func_p1(data, "xcache_get", xc_key);
if (Z_TYPE_P(data) == IS_ARRAY) {
RETURN_CCTOR(data);
}
RETURN_MM_NULL();
}
/**
* Writes the meta-data to APC
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, write){
zval *key, *data, *prefix, *apc_key, *ttl;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &data) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(apc_key);
PHALCON_CONCAT_SVV(apc_key, "$PMM$", prefix, key);
PHALCON_OBS_VAR(ttl);
phalcon_read_property_this(&ttl, this_ptr, SL("_ttl"), PH_NOISY_CC);
PHALCON_CALL_FUNC_PARAMS_3_NORETURN("apc_store", apc_key, data, ttl);
PHALCON_MM_RESTORE();
}
/**
* Returns cached content
*
* @param string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, get){
zval *key_name, *lifetime = NULL, frontend = {}, prefix = {}, prefixed_key = {}, cached_content = {};
phalcon_fetch_params(0, 1, 1, &key_name, &lifetime);
phalcon_return_property(&frontend, getThis(), SL("_frontend"));
phalcon_return_property(&prefix, getThis(), SL("_prefix"));
PHALCON_CONCAT_SVV(&prefixed_key, "_PHCX", &prefix, key_name);
phalcon_update_property_zval(getThis(), SL("_lastKey"), &prefixed_key);
PHALCON_CALL_FUNCTIONW(&cached_content, "xcache_get", &prefixed_key);
if (Z_TYPE(cached_content) == IS_NULL) {
RETURN_NULL();
}
if (phalcon_is_numeric(&cached_content)) {
RETURN_CTORW(&cached_content);
} else {
PHALCON_RETURN_CALL_METHODW(&frontend, "afterretrieve", &cached_content);
}
}
/**
* Returns a cached content
*
* @param string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Apc, get)
{
zval *key_name, *lifetime = NULL, prefixed_key = {}, prefix = {}, frontend = {}, cached_content = {};
phalcon_fetch_params(0, 1, 1, &key_name, &lifetime);
phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY);
PHALCON_CONCAT_SVV(&prefixed_key, "_PHCA", &prefix, key_name);
phalcon_update_property_zval(getThis(), SL("_lastKey"), &prefixed_key);
PHALCON_CALL_FUNCTIONW(&cached_content, "apc_fetch", &prefixed_key);
if (PHALCON_IS_FALSE(&cached_content)) {
RETURN_NULL();
}
if (phalcon_is_numeric(&cached_content)) {
RETURN_CTORW(&cached_content);
} else {
phalcon_read_property(&frontend, getThis(), SL("_frontend"), PH_NOISY);
PHALCON_RETURN_CALL_METHODW(&frontend, "afterretrieve", &cached_content);
}
}
/**
* Returns a cached content
*
* @param string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Apc, get) {
zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key;
zval *cached_content, *processed;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) {
RETURN_MM_NULL();
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SVV(prefixed_key, "_PHCA", prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_FUNC_PARAMS_1(cached_content, "apc_fetch", prefixed_key);
if (PHALCON_IS_FALSE(cached_content)) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(processed);
PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content);
RETURN_CCTOR(processed);
}
/**
* Reads meta-data from APC
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, read){
zval *key, *prefix, *apc_key, *data;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(apc_key);
PHALCON_CONCAT_SVV(apc_key, "$PMM$", prefix, key);
PHALCON_INIT_VAR(data);
PHALCON_CALL_FUNC_PARAMS_1(data, "apc_fetch", apc_key);
if (Z_TYPE_P(data) == IS_ARRAY) {
RETURN_CCTOR(data);
}
RETURN_MM_NULL();
}
/**
* Stores cached content into the XCache backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *frontend, *cached_content = NULL;
zval *prepared_content, *ttl = NULL, *success, *is_buffering;
zval *options, *special_key, *keys = NULL, *zero;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name) {
PHALCON_INIT_VAR(key_name);
}
if (!content) {
PHALCON_INIT_VAR(content);
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
} else {
PHALCON_SEPARATE_PARAM(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_VAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_OBS_VAR(last_key);
phalcon_read_property_this(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_NVAR(last_key);
PHALCON_CONCAT_SVV(last_key, "_PHCX", prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (Z_TYPE_P(content) == IS_NULL) {
PHALCON_INIT_VAR(cached_content);
phalcon_call_method(cached_content, frontend, "getcontent");
} else {
PHALCON_CPY_WRT(cached_content, content);
}
PHALCON_INIT_VAR(prepared_content);
phalcon_call_method_p1(prepared_content, frontend, "beforestore", cached_content);
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_OBS_NVAR(lifetime);
phalcon_read_property_this(&lifetime, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
phalcon_call_method(ttl, frontend, "getlifetime");
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
/**
* Call xcache_set in the PHP userland since most of the time it isn't available at
* compile time
*/
PHALCON_INIT_VAR(success);
phalcon_call_func_p3(success, "xcache_set", last_key, prepared_content, ttl);
PHALCON_INIT_VAR(is_buffering);
phalcon_call_method(is_buffering, frontend, "isbuffering");
if (PHALCON_IS_TRUE(stop_buffer)) {
phalcon_call_method_noret(frontend, "stop");
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
/**
* xcache_set() could fail because of Out of Memory condition. I don't think it is
* appropriate to throw an exception here (like
* Phalcon\Cache\Backend\Memcache::save() does): first, to be consistent with
* Phalcon\Cache\Backend\Apc::save(), second, because xCache is usually given much
* less RAM than memcached
*/
if (zend_is_true(success)) {
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_OBS_VAR(special_key);
phalcon_array_fetch_string(&special_key, options, SL("statsKey"), PH_NOISY_CC);
/**
* xcache_list() is available only to the administrator (unless XCache was
* patched). We have to update the list of the stored keys.
*/
PHALCON_INIT_VAR(keys);
phalcon_call_func_p1(keys, "xcache_get", special_key);
if (Z_TYPE_P(keys) != IS_ARRAY) {
PHALCON_INIT_NVAR(keys);
array_init(keys);
}
if (!zend_is_true(keys)) {
phalcon_array_update_zval(&keys, last_key, &ttl, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
phalcon_call_func_p3_noret("xcache_set", special_key, keys, zero);
}
}
PHALCON_MM_RESTORE();
}
/**
* Stores cached content into the APC backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Apc, save) {
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *frontend, *cached_content = NULL;
zval *prepared_content, *ttl = NULL, *is_buffering;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) {
RETURN_MM_NULL();
}
if (!key_name) {
PHALCON_INIT_VAR(key_name);
}
if (!content) {
PHALCON_INIT_VAR(content);
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_VAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_OBS_VAR(last_key);
phalcon_read_property_this(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_NVAR(last_key);
PHALCON_CONCAT_SVV(last_key, "_PHCA", prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (Z_TYPE_P(content) == IS_NULL) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_METHOD(cached_content, frontend, "getcontent");
} else {
PHALCON_CPY_WRT(cached_content, content);
}
PHALCON_INIT_VAR(prepared_content);
PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content);
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
PHALCON_CALL_METHOD(ttl, frontend, "getlifetime");
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_CALL_FUNC_PARAMS_3_NORETURN("apc_store", last_key, prepared_content, ttl);
PHALCON_INIT_VAR(is_buffering);
PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering");
if (PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD_NORETURN(frontend, "stop");
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Stores cached content into the XCache backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, cached_content = {}, keys = {}, last_key = {}, frontend = {};
zval prepared_content = {}, ttl = {}, success = {}, is_buffering = {}, prefix = {}, options = {}, special_key = {};
phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
phalcon_return_property(&last_key, getThis(), SL("_lastKey"));
} else {
phalcon_return_property(&prefix, getThis(), SL("_prefix"));
PHALCON_CONCAT_SVV(&last_key, "_PHCX", &prefix, key_name);
}
if (!zend_is_true(&last_key)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
phalcon_return_property(&frontend, getThis(), SL("_frontend"));
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent");
} else {
PHALCON_CPY_WRT(&cached_content, content);
}
if (!phalcon_is_numeric(&cached_content)) {
PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content);
}
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
phalcon_return_property(&ttl, getThis(), SL("_lastLifetime"));
if (Z_TYPE(ttl) <= IS_NULL) {
PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime");
}
} else {
PHALCON_CPY_WRT(&ttl, lifetime);
}
if (Z_TYPE(prepared_content) > IS_NULL) {
PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &prepared_content, &ttl);
} else {
PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &cached_content, &ttl);
}
PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHODW(NULL, &frontend, "stop");
}
if (PHALCON_IS_TRUE(&is_buffering)) {
zend_print_zval(&cached_content, 0);
}
phalcon_update_property_bool(getThis(), SL("_started"), 0);
if (zend_is_true(&success)) {
phalcon_return_property(&options, getThis(), SL("_options"));
if (unlikely(!phalcon_array_isset_fetch_str(&special_key, &options, SL("statsKey")))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
/**
* xcache_list() is available only to the administrator (unless XCache was
* patched). We have to update the list of the stored keys.
*/
PHALCON_CALL_FUNCTIONW(&keys, "xcache_get", &special_key);
if (Z_TYPE(keys) != IS_ARRAY) {
array_init(&keys);
}
phalcon_array_update_zval(&keys, &last_key, &ttl, PH_COPY);
PHALCON_CALL_FUNCTIONW(NULL, "xcache_set", &special_key, &keys, &PHALCON_GLOBAL(z_zero));
}
}
/**
* Stores cached content into the APC backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Apc, save)
{
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, prefix = {}, frontend = {};
zval last_key = {}, cached_content = {}, prepared_content = {}, last_lifetime = {}, ttl, is_buffering = {};
phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
phalcon_return_property(&last_key, getThis(), SL("_lastKey"));
} else {
phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY);
PHALCON_CONCAT_SVV(&last_key, "_PHCA", &prefix, key_name);
}
if (!zend_is_true(&last_key)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
phalcon_read_property(&frontend, getThis(), SL("_frontend"), PH_NOISY);
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent");
} else {
PHALCON_CPY_WRT(&cached_content, content);
}
if (!phalcon_is_numeric(&cached_content)) {
PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content);
} else {
PHALCON_CPY_WRT(&prepared_content, &cached_content);
}
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
phalcon_read_property(&last_lifetime, getThis(), SL("_lastLifetime"), PH_NOISY);
if (Z_TYPE(last_lifetime) == IS_NULL) {
PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime");
} else {
PHALCON_CPY_WRT(&ttl, &last_lifetime);
}
} else {
PHALCON_CPY_WRT(&ttl, lifetime);
}
/**
* Call apc_store in the PHP userland since most of the time it isn't available at
* compile time
*/
PHALCON_CALL_FUNCTIONW(NULL, "apc_store", &last_key, &prepared_content, &ttl);
PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHODW(NULL, &frontend, "stop");
}
if (PHALCON_IS_TRUE(&is_buffering)) {
zend_print_zval(&cached_content, 0);
}
phalcon_update_property_bool(getThis(), SL("_started"), 0);
}
/**
* Stores cached content into the XCache backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *cached_content = NULL, *keys = NULL, *last_key, *frontend;
zval *prepared_content = NULL, *ttl = NULL, *success = NULL, *is_buffering = NULL;
zval *prefix, *options, *special_key, *z_zero, *tmp;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_read_property(getThis(), SL("_lastKey"), PH_NOISY);
} else {
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(last_key);
PHALCON_CONCAT_SVV(last_key, "_PHCX", prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
frontend = phalcon_read_property(getThis(), SL("_frontend"), PH_NOISY);
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
if (!phalcon_is_numeric(cached_content)) {
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
}
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
tmp = phalcon_read_property(getThis(), SL("_lastLifetime"), PH_NOISY);
if (Z_TYPE_P(tmp) == IS_NULL) {
PHALCON_CALL_METHOD(&ttl, frontend, "getlifetime");
}
else {
ttl = tmp;
}
} else {
ttl = lifetime;
}
if (!prepared_content) {
PHALCON_CALL_FUNCTION(&success, "xcache_set", last_key, cached_content, ttl);
} else {
PHALCON_CALL_FUNCTION(&success, "xcache_set", last_key, prepared_content, ttl);
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, frontend, "stop");
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(getThis(), SL("_started"), 0);
if (zend_is_true(success)) {
options = phalcon_read_property(getThis(), SL("_options"), PH_NOISY);
if (unlikely(!phalcon_array_isset_str_fetch(&special_key, options, SL("statsKey")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
/**
* xcache_list() is available only to the administrator (unless XCache was
* patched). We have to update the list of the stored keys.
*/
PHALCON_CALL_FUNCTION(&keys, "xcache_get", special_key);
if (Z_TYPE_P(keys) != IS_ARRAY) {
PHALCON_INIT_NVAR(keys);
array_init(keys);
}
z_zero = &PHALCON_GLOBAL(z_zero);
phalcon_array_update_zval(keys, last_key, ttl, PH_COPY);
PHALCON_CALL_FUNCTION(NULL, "xcache_set", special_key, keys, z_zero);
}
PHALCON_MM_RESTORE();
}