/**
* Phalcon\Cache\Backend\Mongo constructor
*
* @param Phalcon\Cache\FrontendInterface $frontend
* @param array $options
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, __construct){
zval *frontend, *options = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
options = PHALCON_GLOBAL(z_null);
}
if (!phalcon_array_isset_string(options, SS("mongo"))) {
if (!phalcon_array_isset_string(options, SS("server"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'server' is required");
return;
}
}
if (!phalcon_array_isset_string(options, SS("db"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'db' is required");
return;
}
if (!phalcon_array_isset_string(options, SS("collection"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'collection' is required");
return;
}
PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_mongo_ce, this_ptr, "__construct", frontend, options);
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, reset)
{
zval *meta = phalcon_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC);
zval *real_key = NULL;
PHALCON_MM_GROW();
if (SUCCESS == phalcon_function_exists_ex(SL("xcache_unset_by_prefix") TSRMLS_CC)) {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(real_key);
phalcon_concat_svs(&real_key, SL("$PMM$"), prefix, SL("meta-"), 0 TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "xcache_unset_by_prefix", real_key);
}
else if (Z_TYPE_P(meta) == IS_ARRAY) {
HashTable *ht = Z_ARRVAL_P(meta);
HashPosition hp;
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
for (
zend_hash_internal_pointer_reset_ex(ht, &hp);
zend_hash_get_current_key_type_ex(ht, &hp) != HASH_KEY_NON_EXISTENT;
zend_hash_move_forward_ex(ht, &hp)
) {
zval key = phalcon_get_current_key_w(ht, &hp);
PHALCON_INIT_NVAR(real_key);
phalcon_concat_svsv(&real_key, SL("$PMM$"), prefix, SL("meta-"), &key, 0 TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "xcache_unset", real_key);
}
}
PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_xcache_ce, getThis(), "reset");
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Http\Request\File constructor
*
* @param array $file
*/
PHP_METHOD(Phalcon_Http_Request_File, __construct){
zval *file, *name, *temp_name, *size, *type, *error, *key = NULL;
zval *constant, *extension = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &file, &key);
if (Z_TYPE_P(file) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "Phalcon\\Http\\Request\\File requires a valid uploaded file");
return;
}
if (phalcon_array_isset_string(file, SS("name"))) {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, file, SL("name"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (zend_get_constant(SL("PATHINFO_EXTENSION"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&extension, "pathinfo", name, constant);
phalcon_update_property_this(this_ptr, SL("_extension"), extension TSRMLS_CC);
}
}
if (phalcon_array_isset_string(file, SS("tmp_name"))) {
PHALCON_OBS_VAR(temp_name);
phalcon_array_fetch_string(&temp_name, file, SL("tmp_name"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_tmp"), temp_name TSRMLS_CC);
} else {
PHALCON_INIT_VAR(temp_name);
ZVAL_NULL(temp_name);
}
if (phalcon_array_isset_string(file, SS("size"))) {
PHALCON_OBS_VAR(size);
phalcon_array_fetch_string(&size, file, SL("size"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC);
}
if (phalcon_array_isset_string(file, SS("type"))) {
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, file, SL("type"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC);
}
if (phalcon_array_isset_string(file, SS("error"))) {
PHALCON_OBS_VAR(error);
phalcon_array_fetch_string(&error, file, SL("error"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_error"), error TSRMLS_CC);
}
if (key) {
phalcon_update_property_this(this_ptr, SL("_key"), key TSRMLS_CC);
}
PHALCON_CALL_PARENT(NULL, phalcon_http_request_file_ce, this_ptr, "__construct", temp_name);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Xcache constructor
*
* @param Phalcon\Cache\FrontendInterface $frontend
* @param array $options
*/
PHP_METHOD(Phalcon_Cache_Backend_Xcache, __construct){
zval *frontend, *options = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
PHALCON_INIT_VAR(options);
} else {
PHALCON_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_INIT_NVAR(options);
array_init(options);
}
if (!phalcon_array_isset_str(options, SL("statsKey"))) {
phalcon_array_update_str_str(options, SL("statsKey"), SL("_PHCX"), PH_COPY);
}
PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_xcache_ce, getThis(), "__construct", frontend, options);
PHALCON_MM_RESTORE();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection.
*
* Support set search_path after connectted if schema is specified in config.
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect){
zval *descriptor = NULL, *schema = NULL, *sql, *password;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC);
}
if (phalcon_array_isset_string(descriptor, SS("schema"))) {
PHALCON_OBS_VAR(schema);
phalcon_array_fetch_string(&schema, descriptor, SL("schema"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("schema"), PH_COPY);
phalcon_update_property_this(this_ptr, SL("_schema"), schema TSRMLS_CC);
}
else {
PHALCON_INIT_VAR(schema);
}
if (phalcon_array_isset_string_fetch(&password, descriptor, SS("password"))) {
/* There is a bug in pdo_pgsql driver when the password is empty,
* the driver tries to access invalid memory:
*
* if (dbh->password[0] != '\'' && dbh->password[strlen(dbh->password) - 1] != '\'')
*
* To avoid this we set the password to null
*/
if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) == 0) {
phalcon_array_update_string(&descriptor, SL("password"), PHALCON_GLOBAL(z_null), PH_COPY);
}
}
PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", descriptor);
/**
* Execute the search path in the after connect
*/
if (Z_TYPE_P(schema) == IS_STRING) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SET search_path TO '", schema, "'");
PHALCON_CALL_METHOD(NULL, this_ptr, "execute", sql);
}
PHALCON_MM_RESTORE();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection.
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, connect) {
zval *descriptor = NULL, *startup, *value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC);
}
/**
* Connect
*/
PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_oracle_ce, this_ptr, "connect", descriptor);
/**
* Database session settings initiated with each HTTP request. Oracle behaviour
* depends on particular NLS* parameter. Check if the developer has defined custom
* startup or create one from scratch
*/
if (phalcon_array_isset_string(descriptor, SS("startup"))) {
PHALCON_OBS_VAR(startup);
phalcon_array_fetch_string(&startup, descriptor, SL("startup"), PH_NOISY);
if (Z_TYPE_P(startup) == IS_ARRAY) {
phalcon_is_iterable(startup, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(value);
PHALCON_CALL_METHOD(NULL, this_ptr, "execute", value);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Mvc\Model\Transaction\Failed constructor
*
* @param string $message
* @param Phalcon\Mvc\ModelInterface $record
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Failed, __construct){
zval *message, *record;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &message, &record);
phalcon_update_property_this(this_ptr, SL("_record"), record TSRMLS_CC);
PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_transaction_failed_ce, this_ptr, "__construct", message);
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Files, reset)
{
zval *metadata_dir, *pattern, *iterator, *itkey = NULL;
zend_object_iterator *it;
PHALCON_MM_GROW();
metadata_dir = phalcon_fetch_nproperty_this(this_ptr, SL("_metaDataDir"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(pattern);
PHALCON_CONCAT_VS(pattern, metadata_dir, "meta-*.php");
PHALCON_INIT_VAR(iterator);
object_init_ex(iterator, spl_ce_GlobIterator);
PHALCON_CALL_METHOD(NULL, iterator, "__construct", pattern);
it = spl_ce_GlobIterator->get_iterator(spl_ce_GlobIterator, iterator, 0 TSRMLS_CC);
it->funcs->rewind(it TSRMLS_CC);
while (SUCCESS == it->funcs->valid(it TSRMLS_CC) && !EG(exception)) {
zval dummy;
#if PHP_VERSION_ID < 50500
char *str_key;
uint str_key_len;
ulong int_key;
int key_type = it->funcs->get_current_key(it, &str_key, &str_key_len, &int_key TSRMLS_CC);
if (likely(key_type == HASH_KEY_IS_STRING)) {
PHALCON_INIT_NVAR(itkey);
/* Note that str_key_len includes the trailing zero */
ZVAL_STRINGL(itkey, str_key, str_key_len-1, 1);
phalcon_unlink(&dummy, itkey TSRMLS_CC);
}
#else
PHALCON_INIT_NVAR(itkey);
it->funcs->get_current_key(it, itkey TSRMLS_CC);
phalcon_unlink(&dummy, itkey TSRMLS_CC);
#endif
it->funcs->move_forward(it TSRMLS_CC);
}
it->funcs->dtor(it TSRMLS_CC);
if (!EG(exception)) {
PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_files_ce, getThis(), "reset");
}
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, reset)
{
zval *redis;
PHALCON_MM_GROW();
redis = phalcon_fetch_nproperty_this(this_ptr, SL("_redis"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(redis) == IS_OBJECT) {
PHALCON_CALL_METHOD(NULL, redis, "flush");
}
PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_redis_ce, getThis(), "reset");
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\File constructor
*
* @param Phalcon\Cache\FrontendInterface $frontend
* @param array $options
*/
PHP_METHOD(Phalcon_Cache_Backend_File, __construct){
zval *frontend, *options = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &frontend, &options);
if (!options || !phalcon_array_isset_string(options, SS("cacheDir"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory must be specified with the option cacheDir");
return;
}
PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_file_ce, this_ptr, "__construct", frontend, options);
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, reset)
{
zval *libmemcached;
PHALCON_MM_GROW();
libmemcached = phalcon_read_property(getThis(), SL("_libmemcached"), PH_NOISY);
if (Z_TYPE_P(libmemcached) == IS_OBJECT) {
PHALCON_CALL_METHOD(NULL, libmemcached, "flush");
}
PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_libmemcached_ce, getThis(), "reset");
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Collection_GridFS, saveBytes){
zval *bytes, *arr = NULL, *white_list = NULL, *mode = NULL;
zval *old_sha1, *old_md5, *sha1 = NULL, *md5 = NULL, *status = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 3, &bytes, &arr, &white_list, &mode);
if (!arr) {
arr = &PHALCON_GLOBAL(z_null);
}
if (!white_list) {
white_list = &PHALCON_GLOBAL(z_null);
}
if (!mode) {
mode = &PHALCON_GLOBAL(z_null);
}
if (zend_is_true(bytes)) {
old_sha1 = phalcon_read_property(getThis(), SL("sha1"), PH_NOISY);
old_md5 = phalcon_read_property(getThis(), SL("md5"), PH_NOISY);
PHALCON_CALL_FUNCTION(&sha1, "sha1", bytes);
PHALCON_CALL_FUNCTION(&md5, "md5", bytes);
phalcon_update_property_this(getThis(), SL("sha1"), sha1);
phalcon_update_property_this(getThis(), SL("md5"), md5);
}
PHALCON_CALL_PARENT(&status, phalcon_mvc_collection_gridfs_ce, getThis(), "save", arr, white_list, mode);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
if (zend_is_true(bytes)) {
PHALCON_CALL_SELF(&status, "store", bytes, &PHALCON_GLOBAL(z_null), &PHALCON_GLOBAL(z_null), &PHALCON_GLOBAL(z_true));
if (zend_is_true(old_sha1)) {
PHALCON_CALL_SELF(NULL, "remove", old_sha1, old_md5);
}
}
RETURN_CTOR(status);
}
/**
* Constructor for Phalcon\Db\Adapter\Pdo
*
* @param array $descriptor
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, __construct){
zval *descriptor;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &descriptor);
if (Z_TYPE_P(descriptor) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The descriptor must be an array");
return;
}
PHALCON_CALL_METHOD(NULL, this_ptr, "connect", descriptor);
PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_ce, this_ptr, "__construct", descriptor);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Libmemcached constructor
*
* @param Phalcon\Cache\FrontendInterface $frontend
* @param array $options
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, __construct){
zval *frontend, *options = NULL, *server, *servers;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
PHALCON_INIT_VAR(options);
} else {
PHALCON_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_INIT_NVAR(options);
array_init(options);
}
if (!phalcon_array_isset_str(options, SL("servers"))) {
PHALCON_INIT_VAR(servers);
array_init_size(servers, 1);
PHALCON_INIT_VAR(server);
array_init_size(server, 3);
phalcon_array_update_str_str(server, SL("host"), SL("127.0.0.1"), PH_COPY);
phalcon_array_update_str_long(server, SL("port"), 11211, PH_COPY);
phalcon_array_update_str_long(server, SL("weight"), 1, PH_COPY);
phalcon_array_append(servers, server, PH_COPY);
phalcon_array_update_str(options, SL("servers"), servers, PH_COPY);
}
if (!phalcon_array_isset_str(options, SL("statsKey"))) {
phalcon_array_update_str_str(options, SL("statsKey"), SL("_PHCM"), PH_COPY);
}
PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_libmemcached_ce, getThis(), "__construct", frontend, options);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Forms\Element constructor
*
* @param string $name
* @param object|array $options
* @param array $attributes
*/
PHP_METHOD(Phalcon_Forms_Element_Select, __construct){
zval *name, *options = NULL, *attributes = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &name, &options, &attributes);
if (!options) {
options = PHALCON_GLOBAL(z_null);
}
if (!attributes) {
attributes = PHALCON_GLOBAL(z_null);
}
phalcon_update_property_this(this_ptr, SL("_optionsValues"), options TSRMLS_CC);
PHALCON_CALL_PARENT(NULL, phalcon_forms_element_select_ce, this_ptr, "__construct", name, attributes);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Cache\Backend\Memcache constructor
*
* @param Phalcon\Cache\FrontendInterface $frontend
* @param array $options
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, __construct){
zval *frontend, *options = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
PHALCON_INIT_VAR(options);
} else {
PHALCON_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_INIT_NVAR(options);
array_init_size(options, 4);
}
if (!phalcon_array_isset_string(options, SS("host"))) {
phalcon_array_update_string_string(&options, SL("host"), SL("127.0.0.1"), PH_COPY);
}
if (!phalcon_array_isset_string(options, SS("port"))) {
phalcon_array_update_string_long(&options, SL("port"), 11211, PH_COPY);
}
if (!phalcon_array_isset_string(options, SS("persistent"))) {
phalcon_array_update_string_bool(&options, SL("persistent"), 0, PH_COPY);
}
if (!phalcon_array_isset_string(options, SS("statsKey"))) {
phalcon_array_update_string_string(&options, SL("statsKey"), SL("_PHCM"), PH_COPY);
}
PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_memcache_ce, this_ptr, "__construct", frontend, options);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\DI\FactoryDefault\CLI constructor
*/
PHP_METHOD(Phalcon_DI_FactoryDefault_CLI, __construct){
zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher;
PHALCON_MM_GROW();
PHALCON_CALL_PARENT(NULL, phalcon_di_factorydefault_cli_ce, this_ptr, "__construct");
shared = PHALCON_GLOBAL(z_true);
PHALCON_INIT_VAR(name);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(name, phalcon_interned_router);
PHALCON_INIT_VAR(definition);
ZVAL_STRING(definition, "Phalcon\\CLI\\Router", 1);
PHALCON_INIT_VAR(router);
object_init_ex(router, phalcon_di_service_ce);
PHALCON_CALL_METHOD(NULL, router, "__construct", name, definition, shared);
phalcon_di_set_service(this_ptr, name, router, PH_COPY TSRMLS_CC);
PHALCON_INIT_NVAR(name);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(name, phalcon_interned_dispatcher);
PHALCON_INIT_NVAR(definition);
ZVAL_STRING(definition, "Phalcon\\CLI\\Dispatcher", 1);
PHALCON_INIT_VAR(dispatcher);
object_init_ex(dispatcher, phalcon_di_service_ce);
PHALCON_CALL_METHOD(NULL, dispatcher, "__construct", name, definition, shared);
phalcon_di_set_service(this_ptr, name, dispatcher, PH_COPY TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Produce the routing parameters from the rewrite information
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){
zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL;
zval *handlers, *controller_suffix, *scope = NULL, *prefix = NULL;
zval *dependency_injector = NULL, *service = NULL, *handler = NULL;
zval *controller_name = NULL;
zval *namespace_name = NULL, *module_name = NULL, *suffixed = NULL;
zval *handler_annotations = NULL, *class_annotations = NULL;
zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL;
zval *collection = NULL, *method = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = PHALCON_GLOBAL(z_null);
}
if (!zend_is_true(uri)) {
/**
* If 'uri' isn't passed as parameter it reads $_GET['_url']
*/
PHALCON_CALL_METHOD(&real_uri, this_ptr, "getrewriteuri");
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_OBS_VAR(processed);
phalcon_read_property_this(&processed, this_ptr, SL("_processed"), PH_NOISY TSRMLS_CC);
if (!zend_is_true(processed)) {
PHALCON_INIT_VAR(annotations_service);
PHALCON_OBS_VAR(handlers);
phalcon_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
PHALCON_OBS_VAR(controller_suffix);
phalcon_read_property_this(&controller_suffix, this_ptr, SL("_controllerSuffix"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(scope);
if (Z_TYPE_P(scope) == IS_ARRAY) {
/**
* A prefix (if any) must be in position 0
*/
PHALCON_OBS_NVAR(prefix);
phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY);
if (Z_TYPE_P(prefix) == IS_STRING) {
if (!phalcon_start_with(real_uri, prefix, NULL)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
if (Z_TYPE_P(annotations_service) != IS_OBJECT) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service");
return;
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_CALL_METHOD(&annotations_service, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(annotations_service, phalcon_annotations_adapterinterface_ce);
}
/**
* The controller must be in position 1
*/
PHALCON_OBS_NVAR(handler);
phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY);
if (phalcon_memnstr_str(handler, SL("\\"))) {
/**
* Extract the real class name from the namespaced class
*/
PHALCON_INIT_NVAR(controller_name);
phalcon_get_class_ns(controller_name, handler, 0 TSRMLS_CC);
/**
* Extract the namespace from the namespaced class
*/
PHALCON_INIT_NVAR(namespace_name);
phalcon_get_ns_class(namespace_name, handler, 0 TSRMLS_CC);
} else {
PHALCON_CPY_WRT(controller_name, handler);
PHALCON_INIT_NVAR(namespace_name);
}
phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC);
/**
* Check if the scope has a module associated
*/
if (phalcon_array_isset_long(scope, 2)) {
PHALCON_OBS_NVAR(module_name);
phalcon_array_fetch_long(&module_name, scope, 2, PH_NOISY);
} else {
PHALCON_INIT_NVAR(module_name);
}
PHALCON_INIT_NVAR(suffixed);
PHALCON_CONCAT_VV(suffixed, handler, controller_suffix);
/**
* Get the annotations from the class
*/
PHALCON_CALL_METHOD(&handler_annotations, annotations_service, "get", suffixed);
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&class_annotations, handler_annotations, "getclassannotations");
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&annotations, class_annotations, "getannotations");
if (Z_TYPE_P(annotations) == IS_ARRAY) {
phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", controller_name, annotation);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
/**
* Process method annotations
*/
PHALCON_CALL_METHOD(&method_annotations, handler_annotations, "getmethodsannotations");
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(method, ah2, hp2);
PHALCON_GET_HVALUE(collection);
if (Z_TYPE_P(collection) == IS_OBJECT) {
PHALCON_CALL_METHOD(&annotations, collection, "getannotations");
phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processactionannotation", module_name, namespace_name, controller_name, method, annotation);
zend_hash_move_forward_ex(ah3, &hp3);
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC);
}
/**
* Call the parent handle method()
*/
PHALCON_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", real_uri);
PHALCON_MM_RESTORE();
}
/**
* Constructor for Phalcon\Session\Adapter\Memcache
*
* @param array $options
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){
zval *options;
zval *host, *port, *lifetime, *persistent, *prefix;
zval *frontend_data, *memcache, *option;
zval *callable_open , *callable_close , *callable_read , *callable_write , *callable_destroy , *callable_gc;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The options must be an array");
return;
}
if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "No session host given in options");
return;
}
if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) {
PHALCON_INIT_VAR(port);
ZVAL_LONG(port, 11211);
}
if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) {
PHALCON_INIT_VAR(lifetime);
ZVAL_LONG(lifetime, 8600);
}
phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) {
PHALCON_INIT_VAR(persistent);
ZVAL_FALSE(persistent);
}
if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) {
PHALCON_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
}
/* create memcache instance */
PHALCON_INIT_VAR(option);
array_init_size(option, 1);
phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY);
PHALCON_INIT_VAR(frontend_data);
object_init_ex(frontend_data, phalcon_cache_frontend_data_ce);
PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option);
PHALCON_INIT_NVAR(option);
array_init_size(option, 3);
phalcon_array_update_string(&option, SL("host"), host, PH_COPY);
phalcon_array_update_string(&option, SL("port"), port, PH_COPY);
phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY);
phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY);
PHALCON_INIT_VAR(memcache);
object_init_ex(memcache, phalcon_cache_backend_memcache_ce);
PHALCON_CALL_METHOD(NULL, memcache, "__construct", frontend_data, option);
phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC);
/* open callback */
PHALCON_INIT_VAR(callable_open);
array_init_size(callable_open, 2);
phalcon_array_append(&callable_open, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_open, SL("open"), 0);
/* close callback */
PHALCON_INIT_VAR(callable_close);
array_init_size(callable_close, 2);
phalcon_array_append(&callable_close, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_close, SL("close"), 0);
/* read callback */
PHALCON_INIT_VAR(callable_read);
array_init_size(callable_read, 2);
phalcon_array_append(&callable_read, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_read, SL("read"), 0);
/* write callback */
PHALCON_INIT_VAR(callable_write);
array_init_size(callable_write, 2);
phalcon_array_append(&callable_write, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_write, SL("write"), 0);
/* destroy callback */
PHALCON_INIT_VAR(callable_destroy);
array_init_size(callable_destroy, 2);
phalcon_array_append(&callable_destroy, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_destroy, SL("destroy"), 0);
/* gc callback */
PHALCON_INIT_VAR(callable_gc);
array_init_size(callable_gc, 2);
phalcon_array_append(&callable_gc, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_gc, SL("gc"), 0);
PHALCON_CALL_FUNCTION(NULL, "session_set_save_handler", callable_open, callable_close, callable_read, callable_write, callable_destroy, callable_gc);
PHALCON_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", options);
PHALCON_MM_RESTORE();
}
