/**
* Cache the actual view render to certain level
*
*<code>
* $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
*</code>
*
* @param boolean|array $options
* @return Phalcon\Mvc\View\Simple
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, cache){
zval *options = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &options);
if (!options) {
PHALCON_INIT_VAR(options);
ZVAL_BOOL(options, 1);
}
if (Z_TYPE_P(options) == IS_ARRAY) {
phalcon_update_property_bool(this_ptr, SL("_cache"), 1 TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_cacheOptions"), options TSRMLS_CC);
} else {
if (zend_is_true(options)) {
phalcon_update_property_bool(this_ptr, SL("_cache"), 1 TSRMLS_CC);
} else {
phalcon_update_property_bool(this_ptr, SL("_cache"), 0 TSRMLS_CC);
}
}
RETURN_THIS();
}
/**
* Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
*
* @param string $name
* @param array $parameters
* @return mixed
*/
PHP_METHOD(Phalcon_DI, getShared){
zval *name, *parameters = NULL, *noerror = NULL, instance = {};
phalcon_fetch_params(0, 1, 2, &name, ¶meters, &noerror);
PHALCON_ENSURE_IS_STRING(name);
if (!parameters) {
parameters = &PHALCON_GLOBAL(z_null);
}
if (!noerror) {
noerror = &PHALCON_GLOBAL(z_null);
}
if (phalcon_isset_property_array(getThis(), SL("_sharedInstances"), name)) {
phalcon_return_property_array(&instance, getThis(), SL("_sharedInstances"), name);
phalcon_update_property_bool(getThis(), SL("_freshInstance"), 0);
} else {
PHALCON_CALL_SELFW(&instance, "get", name, parameters, noerror);
if (zend_is_true(&instance)) {
phalcon_update_property_bool(getThis(), SL("_freshInstance"), 1);
phalcon_update_property_array(getThis(), SL("_sharedInstances"), name, &instance);
}
}
RETURN_CTORW(&instance);
}
/**
* Resets the view component to its factory default values
*
*/
PHP_METHOD(Phalcon_Mvc_View, reset){
phalcon_update_property_bool(this_ptr, SL("_disabled"), 0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_engines"), 0 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_cache") TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_renderLevel"), 5 TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 0 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_content") TSRMLS_CC);
}
/**
* Returns a new Phalcon\Mvc\Model\Transaction or an already created once
* This method registers a shutdown function to rollback active connections
*
* @param boolean $autoBegin
* @return Phalcon\Mvc\Model\TransactionInterface
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get){
zval *auto_begin = NULL, *initialized, *rollback_pendent = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &auto_begin);
if (!auto_begin) {
PHALCON_INIT_VAR(auto_begin);
ZVAL_BOOL(auto_begin, 1);
}
PHALCON_OBS_VAR(initialized);
phalcon_read_property_this(&initialized, this_ptr, SL("_initialized"), PH_NOISY_CC);
if (zend_is_true(initialized)) {
PHALCON_OBS_VAR(rollback_pendent);
phalcon_read_property_this(&rollback_pendent, this_ptr, SL("_rollbackPendent"), PH_NOISY_CC);
if (zend_is_true(rollback_pendent)) {
PHALCON_INIT_NVAR(rollback_pendent);
array_init_size(rollback_pendent, 2);
phalcon_array_append(&rollback_pendent, this_ptr, PH_SEPARATE);
add_next_index_stringl(rollback_pendent, SL("rollbackPendent"), 1);
phalcon_call_func_p1_noret("register_shutdown_function", rollback_pendent);
}
phalcon_update_property_bool(this_ptr, SL("_initialized"), 1 TSRMLS_CC);
}
phalcon_call_method(return_value, this_ptr, "getorcreatetransaction");
RETURN_MM();
}
/**
* Returns the annotations found in the class docblock
*
* @return Phalcon\Annotations\Collection
*/
PHP_METHOD(Phalcon_Annotations_Reflection, getClassAnnotations){
zval *annotations, *reflection_data, *reflection_class;
zval *collection;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(annotations);
phalcon_read_property(&annotations, this_ptr, SL("_classAnnotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) != IS_OBJECT) {
PHALCON_OBS_VAR(reflection_data);
phalcon_read_property(&reflection_data, this_ptr, SL("_reflectionData"), PH_NOISY_CC);
if (phalcon_array_isset_string(reflection_data, SS("class"))) {
PHALCON_OBS_VAR(reflection_class);
phalcon_array_fetch_string(&reflection_class, reflection_data, SL("class"), PH_NOISY_CC);
PHALCON_INIT_VAR(collection);
object_init_ex(collection, phalcon_annotations_collection_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(collection, "__construct", reflection_class);
phalcon_update_property_zval(this_ptr, SL("_classAnnotations"), collection TSRMLS_CC);
RETURN_CTOR(collection);
}
phalcon_update_property_bool(this_ptr, SL("_classAnnotations"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
RETURN_CCTOR(annotations);
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
*
* @param string $handler
* @param string $prefix
* @return Phalcon\Mvc\Router\Annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addResource){
zval *handler, *prefix = NULL, *scope;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &handler, &prefix) == FAILURE) {
RETURN_MM_NULL();
}
if (!prefix) {
PHALCON_INIT_VAR(prefix);
}
if (Z_TYPE_P(handler) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The handler must be a class name");
return;
}
PHALCON_INIT_VAR(scope);
array_init_size(scope, 2);
phalcon_array_append(&scope, prefix, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&scope, handler, PH_SEPARATE TSRMLS_CC);
phalcon_update_property_array_append(this_ptr, SL("_handlers"), scope TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_processed"), 0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Starts a cache. The $keyname allows to identify the created fragment
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend, start){
zval *key_name, *lifetime = NULL, *existing_cache, *fresh = NULL;
zval *frontend;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
/**
* Get the cache content verifying if it was expired
*/
PHALCON_INIT_VAR(existing_cache);
PHALCON_CALL_METHOD_PARAMS_2(existing_cache, this_ptr, "get", key_name, lifetime);
if (Z_TYPE_P(existing_cache) == IS_NULL) {
PHALCON_INIT_VAR(fresh);
ZVAL_BOOL(fresh, 1);
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
PHALCON_CALL_METHOD_NORETURN(frontend, "start");
} else {
PHALCON_INIT_NVAR(fresh);
ZVAL_BOOL(fresh, 0);
}
phalcon_update_property_this(this_ptr, SL("_fresh"), fresh TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
RETURN_CCTOR(existing_cache);
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
* The class is located in a module
*
* @param string $module
* @param string $handler
* @param string $prefix
* @return Phalcon\Mvc\Router\Annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addModuleResource){
zval *module, *handler, *prefix = NULL, *scope;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &module, &handler, &prefix);
if (!prefix) {
PHALCON_INIT_VAR(prefix);
}
if (Z_TYPE_P(module) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The module is not a valid string");
return;
}
if (Z_TYPE_P(handler) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The handler must be a class name");
return;
}
PHALCON_INIT_VAR(scope);
array_init_size(scope, 3);
phalcon_array_append(&scope, prefix, PH_SEPARATE);
phalcon_array_append(&scope, handler, PH_SEPARATE);
phalcon_array_append(&scope, module, PH_SEPARATE);
phalcon_update_property_array_append(this_ptr, SL("_handlers"), scope TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_processed"), 0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Starts a transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, begin){
PHALCON_MM_GROW();
phalcon_update_property_bool(this_ptr, SL("_transaction"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns the annotations found in the properties' docblocks
*
* @return Phalcon\Annotations\Collection[]
*/
PHP_METHOD(Phalcon_Annotations_Reflection, getPropertiesAnnotations){
zval *annotations, *reflection_data, *reflection_properties;
zval *collections, *reflection_property = NULL, *property = NULL;
zval *collection = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(annotations);
phalcon_read_property(&annotations, this_ptr, SL("_propertyAnnotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) != IS_OBJECT) {
PHALCON_OBS_VAR(reflection_data);
phalcon_read_property(&reflection_data, this_ptr, SL("_reflectionData"), PH_NOISY_CC);
if (phalcon_array_isset_string(reflection_data, SS("properties"))) {
PHALCON_OBS_VAR(reflection_properties);
phalcon_array_fetch_string(&reflection_properties, reflection_data, SL("properties"), PH_NOISY_CC);
if (phalcon_fast_count_ev(reflection_properties TSRMLS_CC)) {
PHALCON_INIT_VAR(collections);
array_init(collections);
if (!phalcon_is_iterable(reflection_properties, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(property, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(reflection_property);
PHALCON_INIT_NVAR(collection);
object_init_ex(collection, phalcon_annotations_collection_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(collection, "__construct", reflection_property);
phalcon_array_update_zval(&collections, property, &collection, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_zval(this_ptr, SL("_propertyAnnotations"), collections TSRMLS_CC);
RETURN_CTOR(collections);
}
}
phalcon_update_property_bool(this_ptr, SL("_propertyAnnotations"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
RETURN_CCTOR(annotations);
}
/**
* Resets the view component to its factory default values
*
*/
PHP_METHOD(Phalcon_Mvc_View, reset){
zval *znull;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(znull);
phalcon_update_property_bool(this_ptr, SL("_disabled"), 0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_engines"), 0 TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_cache"), znull TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_renderLevel"), 5 TSRMLS_CC);
phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 0 TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_content"), znull TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_templatesBefore"), znull TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_templatesAfter"), znull TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
*
* @param string $name
* @param array $parameters
* @return mixed
*/
PHP_METHOD(Phalcon_DI, getShared){
zval *name, *parameters = NULL, *shared_instances, *instance = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &name, ¶meters);
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
if (Z_TYPE_P(name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service alias must be a string");
return;
}
/**
* This method provides a first level to shared instances allowing to use
* non-shared services as shared
*/
PHALCON_OBS_VAR(shared_instances);
phalcon_read_property_this(&shared_instances, this_ptr, SL("_sharedInstances"), PH_NOISY_CC);
if (phalcon_array_isset(shared_instances, name)) {
PHALCON_OBS_VAR(instance);
phalcon_array_fetch(&instance, shared_instances, name, PH_NOISY_CC);
phalcon_update_property_bool(this_ptr, SL("_freshInstance"), 0 TSRMLS_CC);
} else {
/**
* Resolve the instance normally
*/
PHALCON_INIT_NVAR(instance);
PHALCON_CALL_METHOD_PARAMS_2(instance, this_ptr, "get", name, parameters);
/**
* Save the instance in the first level shared
*/
phalcon_update_property_array(this_ptr, SL("_sharedInstances"), name, instance TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_freshInstance"), 1 TSRMLS_CC);
}
RETURN_CCTOR(instance);
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Prints out HTTP response to the client
*
* @return Phalcon\Http\ResponseInterface
*/
PHP_METHOD(Phalcon_Http_Response, send){
zval *sent, *headers, *cookies, *content, *file;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(sent);
phalcon_read_property_this(&sent, this_ptr, SL("_sent"), PH_NOISY_CC);
if (PHALCON_IS_FALSE(sent)) {
/**
* Send headers
*/
PHALCON_OBS_VAR(headers);
phalcon_read_property_this(&headers, this_ptr, SL("_headers"), PH_NOISY_CC);
if (Z_TYPE_P(headers) == IS_OBJECT) {
phalcon_call_method_noret(headers, "send");
}
PHALCON_OBS_VAR(cookies);
phalcon_read_property_this(&cookies, this_ptr, SL("_cookies"), PH_NOISY_CC);
if (Z_TYPE_P(cookies) == IS_OBJECT) {
phalcon_call_method_noret(cookies, "send");
}
/**
* Output the response body
*/
PHALCON_OBS_VAR(content);
phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY_CC);
if (Z_STRLEN_P(content)) {
zend_print_zval(content, 0);
}
else {
PHALCON_OBS_VAR(file);
phalcon_read_property_this(&file, this_ptr, SL("_file"), PH_NOISY_CC);
if (Z_STRLEN_P(file)) {
php_stream *stream;
stream = php_stream_open_wrapper(Z_STRVAL_P(file), "rb", REPORT_ERRORS, NULL);
if (stream != NULL) {
php_stream_passthru(stream);
php_stream_close(stream);
}
}
}
phalcon_update_property_bool(this_ptr, SL("_sent"), 1 TSRMLS_CC);
RETURN_THIS();
}
PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "Response was already sent");
return;
}
/**
* Sets the cookie's value
*
* @param string $value
* @return Phalcon\Http\CookieInterface
*/
PHP_METHOD(Phalcon_Http_Cookie, setValue){
zval *value;
phalcon_fetch_params(0, 1, 0, &value);
phalcon_update_property_this(getThis(), SL("_value"), value);
phalcon_update_property_bool(getThis(), SL("_readed"), 1);
RETURN_THISW();
}
/**
* Sets the controller name to be dispatched
*
* @param string $controllerName
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, setControllerName){
zval *controller_name, *is_exact = NULL;
phalcon_fetch_params(0, 1, 1, &controller_name, &is_exact);
if (is_exact && zend_is_true(is_exact)) {
zval *name;
MAKE_STD_ZVAL(name);
PHALCON_CONCAT_SV(name, "\\", controller_name);
phalcon_update_property_this(this_ptr, SL("_handlerName"), name TSRMLS_CC);
zval_ptr_dtor(&name);
phalcon_update_property_bool(this_ptr, SL("_isExactControllerName"), 1 TSRMLS_CC);
}
else {
phalcon_update_property_this(this_ptr, SL("_handlerName"), controller_name TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_isExactControllerName"), 0 TSRMLS_CC);
}
}
/**
* Returns the annotations found in the methods' docblocks
*
* @return Phalcon\Annotations\Collection[]
*/
PHP_METHOD(Phalcon_Annotations_Reflection, getMethodsAnnotations){
zval *annotations, *reflection_data, *reflection_methods;
zval *collections, *reflection_method = NULL, *method_name = NULL;
zval *collection = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(annotations);
phalcon_read_property_this(&annotations, this_ptr, SL("_methodAnnotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) != IS_OBJECT) {
PHALCON_OBS_VAR(reflection_data);
phalcon_read_property_this(&reflection_data, this_ptr, SL("_reflectionData"), PH_NOISY_CC);
if (phalcon_array_isset_string(reflection_data, SS("methods"))) {
PHALCON_OBS_VAR(reflection_methods);
phalcon_array_fetch_string(&reflection_methods, reflection_data, SL("methods"), PH_NOISY_CC);
if (phalcon_fast_count_ev(reflection_methods TSRMLS_CC)) {
PHALCON_INIT_VAR(collections);
array_init(collections);
phalcon_is_iterable(reflection_methods, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(method_name, ah0, hp0);
PHALCON_GET_HVALUE(reflection_method);
PHALCON_INIT_NVAR(collection);
object_init_ex(collection, phalcon_annotations_collection_ce);
phalcon_call_method_p1_noret(collection, "__construct", reflection_method);
phalcon_array_update_zval(&collections, method_name, &collection, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_this(this_ptr, SL("_methodAnnotations"), collections TSRMLS_CC);
RETURN_CTOR(collections);
}
}
phalcon_update_property_bool(this_ptr, SL("_methodAnnotations"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
RETURN_CCTOR(annotations);
}
PHP_METHOD(Phalcon_Session, destroy){
zval *destroyed = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(destroyed);
PHALCON_CALL_FUNC(destroyed, "session_destroy");
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
RETURN_CCTOR(destroyed);
}
/**
* Stops output frontend
*/
PHP_METHOD(Phalcon_Cache_Frontend_Output, stop){
zval *buffering;
buffering = phalcon_read_property(getThis(), SL("_buffering"), PH_NOISY);
if (zend_is_true(buffering)) {
phalcon_ob_end_clean();
}
phalcon_update_property_bool(getThis(), SL("_buffering"), 0);
}
/**
* Stops the event preventing propagation
*/
PHP_METHOD(Phalcon_Events_Event, stop){
zval *cancelable;
cancelable = phalcon_fetch_nproperty_this(this_ptr, SL("_cancelable"), PH_NOISY TSRMLS_CC);
if (zend_is_true(cancelable)) {
phalcon_update_property_bool(this_ptr, SL("_stopped"), 1 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STRW(phalcon_events_exception_ce, "Trying to cancel a non-cancelable event");
return;
}
}
/**
* Resets internal meta-data in order to regenerate it
*/
PHP_METHOD(Phalcon_Model_MetaData, reset){
zval *a0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_update_property_zval(this_ptr, SL("_metaData"), a0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_changed"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Starts a cache. The $keyname allow to identify the created fragment
*
* @param int|string $keyName
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend, start){
zval *key_name = NULL, *backend = NULL, *front_end = NULL, *prefixed_key = NULL;
zval *existing_cache = NULL, *fresh = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_backendOptions"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(backend, t0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_frontendObject"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(front_end, t1);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_prefix"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VV(r0, t2, key_name);
PHALCON_CPY_WRT(prefixed_key, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "get", prefixed_key, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(existing_cache, r1);
PHALCON_INIT_VAR(t3);
ZVAL_NULL(t3);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, existing_cache, t3 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(fresh);
ZVAL_BOOL(fresh, 1);
PHALCON_CALL_METHOD_NORETURN(front_end, "start", PHALCON_NO_CHECK);
} else {
PHALCON_INIT_VAR(fresh);
ZVAL_BOOL(fresh, 0);
}
phalcon_update_property_zval(this_ptr, SL("_fresh"), fresh TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
RETURN_CHECK_CTOR(existing_cache);
}
/**
* Stores cached content into the backend and stops the frontend
*
* @param string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Memory, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *cached_content = NULL, *prepared_content = NULL, *is_buffering = NULL;
zval *last_key, *frontend;
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_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(last_key);
PHALCON_CONCAT_VV(last_key, 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_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
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_update_property_array(this_ptr, SL("_data"), last_key, cached_content TSRMLS_CC);
} else {
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
phalcon_update_property_array(this_ptr, SL("_data"), last_key, prepared_content TSRMLS_CC);
}
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(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
*/
PHP_METHOD(Phalcon_Session_Bag, initialize){
zval *session = NULL, *dependency_injector = NULL, *service;
zval *name, *data = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(session);
phalcon_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC);
if (Z_TYPE_P(session) != IS_OBJECT) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "A dependency injection object is required to access the 'session' service");
return;
}
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "session", 1);
PHALCON_INIT_NVAR(session);
phalcon_call_method_p1(session, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce);
phalcon_update_property_this(this_ptr, SL("_session"), session TSRMLS_CC);
}
PHALCON_OBS_VAR(name);
phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
PHALCON_INIT_VAR(data);
phalcon_call_method_p1(data, session, "get", name);
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_initalized"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Starts the session (if headers are already sent the session will not started)
*
* @return boolean
*/
PHP_METHOD(Phalcon_Session_Adapter, start){
zval *headers_sent;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_sent);
PHALCON_CALL_FUNC(headers_sent, "headers_sent");
if (PHALCON_IS_FALSE(headers_sent)) {
PHALCON_CALL_FUNC_NORETURN("session_start");
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Starts session, optionally using an adapter
*
* @param array $options
*/
PHP_METHOD(Phalcon_Session, start){
zval *headers_sent = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_sent);
PHALCON_CALL_FUNC(headers_sent, "headers_sent");
if (Z_TYPE_P(headers_sent) == IS_BOOL && !Z_BVAL_P(headers_sent)) {
PHALCON_CALL_FUNC_NORETURN("session_start");
phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Reads the cookie-related info from the SESSION to restore the cookie as it was set
* This method is automatically called internally so normally you don't need to call it
*
* @return Phalcon\Http\Cookie
*/
PHP_METHOD(Phalcon_Http_Cookie, restore)
{
zval *restored, *dependency_injector, service = {}, session = {}, name = {}, key = {}, definition = {}, expire = {}, domain = {}, path = {}, secure = {}, http_only = {};
restored = phalcon_read_property(getThis(), SL("_restored"), PH_NOISY);
if (!zend_is_true(restored)) {
dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY);
if (Z_TYPE_P(dependency_injector) == IS_OBJECT) {
ZVAL_STRING(&service, ISV(session));
PHALCON_CALL_METHODW(&session, dependency_injector, "getshared", &service);
PHALCON_VERIFY_INTERFACEW(&session, phalcon_session_adapterinterface_ce);
phalcon_return_property(&name, getThis(), SL("_name"));
PHALCON_CONCAT_SV(&key, "_PHCOOKIE_", &name);
PHALCON_CALL_METHODW(&definition, &session, "get", &key);
if (Z_TYPE(definition) == IS_ARRAY) {
if (phalcon_array_isset_fetch_str(&expire, &definition, SL("expire"))) {
phalcon_update_property_this(getThis(), SL("_expire"), &expire);
}
if (phalcon_array_isset_fetch_str(&domain, &definition, SL("domain"))) {
phalcon_update_property_this(getThis(), SL("_domain"), &domain);
}
if (phalcon_array_isset_fetch_str(&path, &definition, SL("path"))) {
phalcon_update_property_this(getThis(), SL("_path"), &path);
}
if (phalcon_array_isset_fetch_str(&secure, &definition, SL("secure"))) {
phalcon_update_property_this(getThis(), SL("_secure"), &secure);
}
if (phalcon_array_isset_fetch_str(&http_only, &definition, SL("httpOnly"))) {
phalcon_update_property_this(getThis(), SL("_httpOnly"), &http_only);
}
}
}
phalcon_update_property_bool(getThis(), SL("_restored"), 1);
}
RETURN_THISW();
}
/**
* Phalcon\Http\Cookie constructor
*
* @param string $name
* @param mixed $value
* @param int $expire
* @param string $path
* @param boolean $secure
* @param string $domain
* @param boolean $httpOnly
*/
PHP_METHOD(Phalcon_Http_Cookie, __construct){
zval **name, **value = NULL, **expire = NULL, **path = NULL, **secure = NULL, **domain = NULL;
zval **http_only = NULL;
phalcon_fetch_params_ex(1, 6, &name, &value, &expire, &path, &secure, &domain, &http_only);
PHALCON_ENSURE_IS_STRING(name);
if (!expire) {
expire = &PHALCON_GLOBAL(z_zero);
}
phalcon_update_property_this(this_ptr, SL("_name"), *name TSRMLS_CC);
if (value && Z_TYPE_PP(value) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_value"), *value TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_readed"), 1 TSRMLS_CC);
}
phalcon_update_property_this(this_ptr, SL("_expire"), *expire TSRMLS_CC);
if (path && Z_TYPE_PP(path) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_path"), *path TSRMLS_CC);
}
else {
zval *path;
PHALCON_ALLOC_GHOST_ZVAL(path);
ZVAL_STRINGL(path, "/", 1, 1);
phalcon_update_property_this(this_ptr, SL("_path"), path TSRMLS_CC);
}
if (secure && Z_TYPE_PP(secure) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_secure"), *secure TSRMLS_CC);
}
if (domain && Z_TYPE_PP(domain) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_domain"), *domain TSRMLS_CC);
}
if (http_only && Z_TYPE_PP(http_only) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_httpOnly"), *http_only TSRMLS_CC);
}
}
/**
* Phalcon\Logger\Adapter\Syslog constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_Syslog, __construct){
zval *name, *options = NULL, *option = NULL, *facility = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &name, &options);
if (!options) {
PHALCON_INIT_VAR(options);
}
/**
* We use 'fopen' to respect to open-basedir directive
*/
if (zend_is_true(name)) {
if (phalcon_array_isset_string(options, SS("option"))) {
PHALCON_OBS_VAR(option);
phalcon_array_fetch_string(&option, options, SL("option"), PH_NOISY);
} else {
/**
* Open the log in LOG_ODELAY mode
*/
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, 4);
}
if (phalcon_array_isset_string(options, SS("facility"))) {
PHALCON_OBS_VAR(facility);
phalcon_array_fetch_string(&facility, options, SL("facility"), PH_NOISY);
} else {
/**
* By default the facility is LOG_USER
*/
PHALCON_INIT_NVAR(facility);
ZVAL_LONG(facility, 8);
}
phalcon_call_func_p3_noret("openlog", name, option, facility);
phalcon_update_property_bool(this_ptr, SL("_opened"), 1 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Logger\Adapter\Syslog constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_Syslog, __construct){
zval *name, *options = NULL, *option = NULL, *facility = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &name, &options);
if (!options) {
options = &PHALCON_GLOBAL(z_null);
}
/**
* We use 'fopen' to respect to open-basedir directive
*/
if (zend_is_true(name)) {
if (phalcon_array_isset_str(options, SL("option"))) {
PHALCON_OBS_VAR(option);
phalcon_array_fetch_str(&option, options, SL("option"), PH_NOISY);
} else {
/**
* Open the log in LOG_ODELAY mode
*/
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, 4);
}
if (phalcon_array_isset_str(options, SL("facility"))) {
PHALCON_OBS_VAR(facility);
phalcon_array_fetch_str(&facility, options, SL("facility"), PH_NOISY);
} else {
/**
* By default the facility is LOG_USER
*/
PHALCON_INIT_NVAR(facility);
ZVAL_LONG(facility, 8);
}
PHALCON_CALL_FUNCTION(NULL, "openlog", name, option, facility);
phalcon_update_property_bool(getThis(), SL("_opened"), 1);
}
PHALCON_MM_RESTORE();
}