/** * 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(); }