/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize){ zval *type = NULL, *result = NULL, *records = NULL, *row_count = NULL, *model = NULL; zval *cache = NULL, *data = NULL, *serialized = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_CALL_METHOD_NORETURN(result, "execute", PH_NO_CHECK); PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, result, "fetchall", PH_NO_CHECK); } else { PHALCON_INIT_VAR(records); array_init(records); } } else { PHALCON_INIT_VAR(records); phalcon_read_property(&records, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(records) == IS_NULL) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, result, "fetchall", PH_NO_CHECK); PHALCON_INIT_VAR(row_count); phalcon_fast_count(row_count, records TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_rows"), row_count TSRMLS_CC); } } } PHALCON_INIT_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); PHALCON_INIT_VAR(cache); phalcon_read_property(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init(data); phalcon_array_update_string(&data, SL("model"), &model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Returns a complete resultset as an array, if the resultset has a big number of rows * it could consume more memory than currently it does. * * @return array */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, toArray){ zval *records, *valid = NULL, *current = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(records); array_init(records); phalcon_call_method_noret(this_ptr, "rewind"); while (1) { PHALCON_INIT_NVAR(r0); phalcon_call_method(r0, this_ptr, "valid"); PHALCON_CPY_WRT(valid, r0); if (PHALCON_IS_NOT_FALSE(valid)) { } else { break; } PHALCON_INIT_NVAR(current); phalcon_call_method(current, this_ptr, "current"); phalcon_array_append(&records, current, PH_SEPARATE); phalcon_call_method_noret(this_ptr, "next"); } RETURN_CTOR(records); }
/** * Phalcon\Mvc\Model\Resultset\Complex constructor * * @param array $columnsTypes * @param Phalcon\Db\ResultInterface $result * @param Phalcon\Cache\BackendInterface $cache */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, __construct){ zval *columns_types, *result, *cache = NULL, *fetch_assoc; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &columns_types, &result, &cache) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!cache) { PHALCON_INIT_NVAR(cache); } phalcon_update_property_zval(this_ptr, SL("_columnTypes"), columns_types TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_result"), result TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC); phalcon_update_property_long(this_ptr, SL("_type"), 1 TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(fetch_assoc); ZVAL_LONG(fetch_assoc, 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", fetch_assoc, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Get first row in the resultset * * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getFirst){ zval *pointer, *valid = NULL; PHALCON_MM_GROW(); /** * Check if the last record returned is the current requested */ pointer = phalcon_read_property(getThis(), SL("_pointer"), PH_NOISY); if (PHALCON_IS_LONG(pointer, 0)) { PHALCON_RETURN_CALL_METHOD(getThis(), "current"); RETURN_MM(); } /** * Otherwise re-execute the statement */ PHALCON_CALL_METHOD(NULL, getThis(), "rewind"); PHALCON_CALL_METHOD(&valid, getThis(), "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_RETURN_CALL_METHOD(getThis(), "current"); RETURN_MM(); } RETURN_MM_FALSE; }
/** * Get first row in the resultset * * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getFirst){ zval *pointer, *current = NULL, *valid; PHALCON_MM_GROW(); /** * Check if the last record returned is the current requested */ PHALCON_OBS_VAR(pointer); phalcon_read_property_this(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); if (PHALCON_IS_LONG(pointer, 0)) { PHALCON_INIT_VAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } /** * Otherwise re-execute the statement */ phalcon_call_method_noret(this_ptr, "rewind"); PHALCON_INIT_VAR(valid); phalcon_call_method(valid, this_ptr, "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_INIT_NVAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } RETURN_MM_FALSE; }
/** * Get last row in the resultset * * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getLast){ zval *one, *count, *pre_count, *valid, *current; PHALCON_MM_GROW(); PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(count); phalcon_call_method(count, this_ptr, "count"); PHALCON_INIT_VAR(pre_count); sub_function(pre_count, count, one TSRMLS_CC); phalcon_call_method_p1_noret(this_ptr, "seek", pre_count); PHALCON_INIT_VAR(valid); phalcon_call_method(valid, this_ptr, "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_INIT_VAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } RETURN_MM_FALSE; }
/** * Counts how many rows are in the resultset * * @return int */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, count){ zval *count = NULL, *type, *result = NULL, *number_rows, *rows = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(count); phalcon_read_property_this(&count, this_ptr, SL("_count"), PH_NOISY_CC); /** * We only calculate the row number is it wasn't calculated before */ if (Z_TYPE_P(count) == IS_NULL) { PHALCON_INIT_NVAR(count); ZVAL_LONG(count, 0); PHALCON_OBS_VAR(type); phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset act as a result that is fetched one by one */ PHALCON_OBS_VAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(number_rows); phalcon_call_method(number_rows, result, "numrows"); PHALCON_INIT_NVAR(count); ZVAL_LONG(count, phalcon_get_intval(number_rows)); } } else { /** * Here, the resultset act as an array */ PHALCON_OBS_VAR(rows); phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_NVAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (Z_TYPE_P(result) == IS_OBJECT) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC); } } PHALCON_INIT_NVAR(count); phalcon_fast_count(count, rows TSRMLS_CC); } phalcon_update_property_this(this_ptr, SL("_count"), count TSRMLS_CC); } RETURN_CCTOR(count); }
/** * Appends an array of messages to the group * *<code> * $messages->appendMessages($messagesArray); *</code> * * @param Phalcon\Validation\MessageInterface[] $messages */ PHP_METHOD(Phalcon_Validation_Message_Group, appendMessages){ zval *messages, *current_messages, *final_messages = NULL; zval *message = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &messages) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(messages) != IS_ARRAY) { if (Z_TYPE_P(messages) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The messages must be array or object"); return; } } PHALCON_OBS_VAR(current_messages); phalcon_read_property(¤t_messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (Z_TYPE_P(messages) == IS_ARRAY) { /** * An array of messages is simply merged into the current one */ if (Z_TYPE_P(current_messages) == IS_ARRAY) { PHALCON_INIT_VAR(final_messages); PHALCON_CALL_FUNC_PARAMS_2(final_messages, "array_merge", current_messages, messages); } else { PHALCON_CPY_WRT(final_messages, messages); } phalcon_update_property_zval(this_ptr, SL("_messages"), final_messages TSRMLS_CC); } else { /** * A group of messages is iterated and appended one-by-one to the current list */ PHALCON_CALL_METHOD_NORETURN(messages, "rewind"); while (1) { PHALCON_INIT_NVAR(r0); PHALCON_CALL_METHOD(r0, messages, "valid"); if (PHALCON_IS_NOT_FALSE(r0)) { } else { break; } PHALCON_INIT_NVAR(message); PHALCON_CALL_METHOD(message, messages, "current"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "appendmessage", message); PHALCON_CALL_METHOD_NORETURN(messages, "next"); } } PHALCON_MM_RESTORE(); }
/** * Rewinds resultset to its beginning * */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind){ zval *type, *result = NULL, *active_row, *zero, *rows = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(type); phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset act as a result that is fetched one by one */ PHALCON_OBS_VAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_OBS_VAR(active_row); phalcon_read_property_this(&active_row, this_ptr, SL("_activeRow"), PH_NOISY_CC); if (Z_TYPE_P(active_row) != IS_NULL) { PHALCON_INIT_VAR(zero); ZVAL_LONG(zero, 0); phalcon_call_method_p1_noret(result, "dataseek", zero); } } } else { /** * Here, the resultset act as an array */ PHALCON_OBS_VAR(rows); phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_NVAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (Z_TYPE_P(result) == IS_OBJECT) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC); } } if (Z_TYPE_P(rows) == IS_ARRAY) { Z_SET_ISREF_P(rows); phalcon_call_func_p1_noret("reset", rows); Z_UNSET_ISREF_P(rows); } } phalcon_update_property_long(this_ptr, SL("_pointer"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Rewinds resultset to its beginning * */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind){ zval *type, *z_zero, *rows; z_zero = &PHALCON_GLOBAL(z_zero); type = phalcon_read_property(getThis(), SL("_type"), PH_NOISY); if (zend_is_true(type)) { /** * Here, the resultset act as a result that is fetched one by one */ zval *result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY); if (PHALCON_IS_NOT_FALSE(result)) { zval *active_row = phalcon_read_property(getThis(), SL("_activeRow"), PH_NOISY); if (Z_TYPE_P(active_row) != IS_NULL) { PHALCON_MM_GROW(); PHALCON_CALL_METHOD(NULL, result, "dataseek", z_zero); PHALCON_MM_RESTORE(); } } } else { /** * Here, the resultset act as an array */ rows = phalcon_read_property(getThis(), SL("_rows"), PH_NOISY); if (Z_TYPE_P(rows) == IS_NULL) { zval *result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY); if (Z_TYPE_P(result) == IS_OBJECT) { zval *r = NULL; PHALCON_CALL_METHODW(&r, result, "fetchall"); if (likely(Z_TYPE_P(r) == IS_ARRAY)) { zend_hash_internal_pointer_reset(Z_ARRVAL_P(r)); } phalcon_update_property_this(getThis(), SL("_rows"), r); zval_ptr_dtor(r); } } else if (Z_TYPE_P(rows) == IS_ARRAY) { zend_hash_internal_pointer_reset(Z_ARRVAL_P(rows)); } } phalcon_update_property_this(getThis(), SL("_pointer"), z_zero); }
/** * Gets row in a specific position of the resultset * * @param int $index * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet){ zval *index, *count, *exists, *pointer, *current = NULL, *valid; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &index); PHALCON_INIT_VAR(count); phalcon_call_method(count, this_ptr, "count"); PHALCON_INIT_VAR(exists); is_smaller_function(exists, index, count TSRMLS_CC); if (PHALCON_IS_TRUE(exists)) { /** * Check if the last record returned is the current requested */ PHALCON_OBS_VAR(pointer); phalcon_read_property_this(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); if (PHALCON_IS_EQUAL(pointer, index)) { PHALCON_INIT_VAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } /** * Move the cursor to the specific position */ phalcon_call_method_p1_noret(this_ptr, "seek", index); /** * Check if the last record returned is the requested */ PHALCON_INIT_VAR(valid); phalcon_call_method(valid, this_ptr, "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_INIT_NVAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } RETURN_MM_FALSE; } PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor"); return; }
/** * Phalcon\Mvc\Model\Resultset\Simple constructor * * @param Phalcon\Mvc\Model $model * @param Phalcon\Db\Result\Pdo $result * @param Phalcon\Cache\Backend $cache */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct){ zval *model = NULL, *result = NULL, *cache = NULL, *fetch_assoc = NULL, *limit = NULL; zval *row_count = NULL, *big_resultset = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &model, &result, &cache) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!cache) { PHALCON_ALLOC_ZVAL_MM(cache); ZVAL_NULL(cache); } phalcon_update_property_zval(this_ptr, SL("_model"), model TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_result"), result TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(fetch_assoc); ZVAL_LONG(fetch_assoc, 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(limit); ZVAL_LONG(limit, 32); PHALCON_INIT_VAR(row_count); PHALCON_CALL_METHOD(row_count, result, "numrows", PH_NO_CHECK); PHALCON_INIT_VAR(big_resultset); is_smaller_function(big_resultset, limit, row_count TSRMLS_CC); if (PHALCON_IS_TRUE(big_resultset)) { phalcon_update_property_long(this_ptr, SL("_type"), 1 TSRMLS_CC); } else { phalcon_update_property_long(this_ptr, SL("_type"), 0 TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_count"), row_count TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Gets row in a specific position of the resultset * * @param int $index * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet){ zval *index, *count = NULL, *pointer, *valid = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &index); PHALCON_CALL_METHOD(&count, getThis(), "count"); if (PHALCON_LT(index, count)) { /** * Check if the last record returned is the current requested */ pointer = phalcon_read_property(getThis(), SL("_pointer"), PH_NOISY); if (PHALCON_IS_EQUAL(pointer, index)) { PHALCON_RETURN_CALL_METHOD(getThis(), "current"); RETURN_MM(); } /** * Move the cursor to the specific position */ PHALCON_CALL_METHOD(NULL, getThis(), "seek", index); /** * Check if the last record returned is the requested */ PHALCON_CALL_METHOD(&valid, getThis(), "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_RETURN_CALL_METHOD(getThis(), "current"); RETURN_MM(); } RETURN_MM_FALSE; } PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor"); return; }
/** * Returns a complete resultset as an array, if the resultset has a big number of rows * it could consume more memory than currently it does. * * @return array */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, toArray){ zval *valid = NULL, *current = NULL; PHALCON_MM_GROW(); array_init(return_value); PHALCON_CALL_METHOD(NULL, this_ptr, "rewind"); while (1) { PHALCON_CALL_METHOD(&valid, this_ptr, "valid"); if (!PHALCON_IS_NOT_FALSE(valid)) { break; } PHALCON_CALL_METHOD(¤t, this_ptr, "current"); phalcon_array_append(&return_value, current, 0); PHALCON_CALL_METHOD(NULL, this_ptr, "next"); } PHALCON_MM_RESTORE(); }
/** * Get last row in the resultset * * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getLast){ zval *z_one, *count = NULL, *pre_count, *valid = NULL; PHALCON_MM_GROW(); z_one = &PHALCON_GLOBAL(z_one); PHALCON_CALL_METHOD(&count, getThis(), "count"); PHALCON_INIT_VAR(pre_count); phalcon_sub_function(pre_count, count, z_one); PHALCON_CALL_METHOD(NULL, getThis(), "seek", pre_count); PHALCON_CALL_METHOD(&valid, getThis(), "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_RETURN_CALL_METHOD(getThis(), "current"); RETURN_MM(); } RETURN_MM_FALSE; }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){ zval *type = NULL, *result, *row = NULL, *rows, *hydrate_mode, *underscore; zval *empty_str, *active_row = NULL, *columns_types; zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL; zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL; zval *column_value = NULL, *keep_snapshots = NULL, *instance = NULL; zval *value = NULL, *sql_alias = NULL, *n_alias = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); PHALCON_OBS_VAR(type); phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * The result is bigger than 32 rows so it's retrieved one by one */ PHALCON_OBS_VAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result); } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } else { /** * The full rows are dumped in this_ptr->rows */ PHALCON_OBS_VAR(rows); phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) == IS_ARRAY) { PHALCON_INIT_NVAR(row); phalcon_array_get_current(row, rows TSRMLS_CC); if (Z_TYPE_P(row) == IS_OBJECT) { phalcon_array_next(rows); } } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } /** * Valid records are arrays */ if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) { /** * The result type=1 so we need to build every row */ if (zend_is_true(type)) { /** * Get current hydration mode */ PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); /** * Each row in a complex result is a Phalcon\Mvc\Model\Row instance */ switch (phalcon_get_intval(hydrate_mode)) { case 0: PHALCON_INIT_VAR(active_row); object_init_ex(active_row, phalcon_mvc_model_row_ce); break; case 1: PHALCON_INIT_NVAR(active_row); array_init(active_row); break; case 2: PHALCON_INIT_NVAR(active_row); object_init(active_row); break; } /** * Create every record according to the column types */ PHALCON_OBS_VAR(columns_types); phalcon_read_property_this(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC); /** * Set records as dirty state PERSISTENT by default */ PHALCON_INIT_VAR(dirty_state); ZVAL_LONG(dirty_state, 0); if (!phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah0, hp0); PHALCON_GET_FOREACH_VALUE(column); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY_CC); if (PHALCON_IS_STRING(type, "object")) { /** * Object columns are assigned column by column */ PHALCON_OBS_NVAR(source); phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY_CC); PHALCON_OBS_NVAR(attributes); phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY_CC); PHALCON_OBS_NVAR(column_map); phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY_CC); /** * Assign the values from the _source_attribute notation to its real column name */ PHALCON_INIT_NVAR(row_model); array_init(row_model); if (!phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(attribute); /** * Columns are supposed to be in the form _table_field */ PHALCON_INIT_NVAR(column_alias); PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute); PHALCON_OBS_NVAR(column_value); phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY_CC); phalcon_array_update_zval(&row_model, attribute, &column_value, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } /** * Generate the column value according to the hydration type */ switch (phalcon_get_intval(hydrate_mode)) { case 0: /** * Check if the resultset must keep snapshots */ if (phalcon_array_isset_string(column, SS("keepSnapshots"))) { PHALCON_OBS_NVAR(keep_snapshots); phalcon_array_fetch_string(&keep_snapshots, column, SL("keepSnapshots"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(keep_snapshots); ZVAL_BOOL(keep_snapshots, 0); } /** * Get the base instance */ PHALCON_OBS_NVAR(instance); phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY_CC); /** * Assign the values to the attributes using a column map */ PHALCON_INIT_NVAR(value); PHALCON_CALL_STATIC_PARAMS_5(value, "phalcon\\mvc\\model", "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots); break; default: /** * Other kinds of hydrations */ PHALCON_INIT_NVAR(value); PHALCON_CALL_STATIC_PARAMS_3(value, "phalcon\\mvc\\model", "cloneresultmaphydrate", row_model, column_map, hydrate_mode); break; } /** * The complete object is assigned to an attribute with the name of the alias or * the model name */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY_CC); } else { /** * Scalar columns are simply assigned to the result object */ if (phalcon_array_isset_string(column, SS("sqlAlias"))) { PHALCON_OBS_NVAR(sql_alias); phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY_CC); PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, row, sql_alias, PH_NOISY_CC); } else { PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, row, alias, PH_NOISY_CC); } /** * If a 'balias' is defined is not an unnamed scalar */ if (phalcon_array_isset_string(column, SS("balias"))) { PHALCON_CPY_WRT(attribute, alias); } else { PHALCON_INIT_NVAR(n_alias); phalcon_fast_str_replace(n_alias, underscore, empty_str, alias TSRMLS_CC); PHALCON_CPY_WRT(attribute, n_alias); } } /** * Assign the instance according to the hydration type */ switch (phalcon_get_intval(hydrate_mode)) { case 1: phalcon_array_update_zval(&active_row, attribute, &value, PH_COPY | PH_SEPARATE TSRMLS_CC); break; default: phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC); break; } zend_hash_move_forward_ex(ah0, &hp0); } /** * Store the generated row in this_ptr->activeRow to be retrieved by 'current' */ phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); } else { /** * The row is already built so we just assign it to the activeRow */ phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC); } RETURN_MM_TRUE; } /** * There are no results to retrieve so we update this_ptr->activeRow as false */ phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); RETURN_MM_FALSE; }
/** * Returns a slice of the resultset to show in the pagination * * @return stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){ zval *one, *zero, *show, *config, *items, *page_number = NULL; zval *smaller, *n, *page, *last_show_page, *start; zval *last_page, *possible_pages = NULL, *total_pages; zval *compare = NULL, *page_items, *i, *valid = NULL, *current = NULL, *maximum_pages; zval *next = NULL, *additional_page, *before = NULL, *remainder; zval *pages_total = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(zero); ZVAL_LONG(zero, 0); PHALCON_OBS_VAR(show); phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC); PHALCON_OBS_VAR(config); phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC); PHALCON_OBS_VAR(items); phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC); PHALCON_OBS_VAR(page_number); phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC); if (Z_TYPE_P(page_number) == IS_NULL) { PHALCON_CPY_WRT(page_number, one); } PHALCON_INIT_VAR(smaller); is_smaller_function(smaller, show, zero TSRMLS_CC); if (PHALCON_IS_TRUE(smaller)) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less"); return; } PHALCON_INIT_VAR(n); phalcon_fast_count(n, items TSRMLS_CC); PHALCON_INIT_VAR(page); object_init(page); PHALCON_INIT_VAR(last_show_page); sub_function(last_show_page, page_number, one TSRMLS_CC); PHALCON_INIT_VAR(start); mul_function(start, show, last_show_page TSRMLS_CC); PHALCON_INIT_VAR(last_page); sub_function(last_page, n, one TSRMLS_CC); PHALCON_INIT_VAR(possible_pages); div_function(possible_pages, last_page, show TSRMLS_CC); PHALCON_INIT_VAR(total_pages); PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages); if (Z_TYPE_P(items) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator"); return; } if (Z_TYPE_P(page_number) == IS_NULL) { PHALCON_CPY_WRT(page_number, zero); } PHALCON_INIT_VAR(compare); is_smaller_function(compare, start, zero TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less"); return; } PHALCON_INIT_VAR(page_items); array_init(page_items); is_smaller_function(compare, zero, n TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { /** * Seek to the desired position */ is_smaller_or_equal_function(compare, start, n TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start); } else { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one); PHALCON_CPY_WRT(page_number, one); } /** * The record must be iterable */ PHALCON_INIT_VAR(i); ZVAL_LONG(i, 1); while (1) { PHALCON_INIT_NVAR(r0); PHALCON_CALL_METHOD(r0, items, "valid"); PHALCON_CPY_WRT(valid, r0); if (PHALCON_IS_NOT_FALSE(valid)) { } else { break; } PHALCON_INIT_NVAR(current); PHALCON_CALL_METHOD(current, items, "current"); phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(compare); is_smaller_or_equal_function(compare, show, i TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { break; } PHALCON_SEPARATE(i); increment_function(i); } } phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC); phalcon_update_property_zval(page, SL("first"), one TSRMLS_CC); PHALCON_INIT_VAR(maximum_pages); phalcon_add_function(maximum_pages, start, show TSRMLS_CC); is_smaller_function(compare, maximum_pages, n TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_INIT_VAR(next); phalcon_add_function(next, page_number, one TSRMLS_CC); } else { is_equal_function(compare, maximum_pages, n TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_CPY_WRT(next, n); } else { div_function(possible_pages, n, show TSRMLS_CC); PHALCON_INIT_VAR(additional_page); phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC); PHALCON_INIT_NVAR(next); PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page); } } is_smaller_function(compare, total_pages, next TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_CPY_WRT(next, total_pages); } phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC); is_smaller_function(compare, one, page_number TSRMLS_CC); if (PHALCON_IS_TRUE(compare)) { PHALCON_INIT_VAR(before); sub_function(before, page_number, one TSRMLS_CC); } else { PHALCON_CPY_WRT(before, one); } phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC); phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC); PHALCON_INIT_VAR(remainder); mod_function(remainder, n, show TSRMLS_CC); div_function(possible_pages, n, show TSRMLS_CC); if (!PHALCON_IS_LONG(remainder, 0)) { PHALCON_INIT_NVAR(next); phalcon_add_function(next, possible_pages, one TSRMLS_CC); PHALCON_INIT_VAR(pages_total); PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", next); } else { PHALCON_CPY_WRT(pages_total, possible_pages); } phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC); phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC); RETURN_CTOR(page); }
/** * Changes internal pointer to a specific position in the resultset * * @param int $position */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){ long i; zval *type, *result, *rows, *position; zval *pointer, *is_different; HashTable *ah0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_OBS_VAR(pointer); phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); /** * We only seek the records if the current position is diferent than the passed one */ PHALCON_INIT_VAR(is_different); is_not_equal_function(is_different, pointer, position TSRMLS_CC); if (PHALCON_IS_TRUE(is_different)) { PHALCON_OBS_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset is fetched one by one because is large */ PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); phalcon_call_method_p1_noret(result, "dataseek", position); } else { /** * Here, the resultset is a small array */ PHALCON_OBS_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); /** * We need to fetch the records because rows is null */ if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } convert_to_long(position); if(Z_TYPE_P(rows) == IS_ARRAY){ ah0 = Z_ARRVAL_P(rows); zend_hash_internal_pointer_reset(ah0); i = 0; while (1) { if (i >= Z_LVAL_P(position)) { break; } zend_hash_move_forward(ah0); i++; } } phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC); } } PHALCON_MM_RESTORE();}
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){ zval *type = NULL, *row = NULL, *underscore; zval *empty_str, *active_row = NULL; zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL; zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL; zval *column_value = NULL; zval *value = NULL, *sql_alias = NULL, *n_alias = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int i_type, is_partial; PHALCON_MM_GROW(); type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC); i_type = (Z_TYPE_P(type) == IS_LONG) ? Z_LVAL_P(type) : phalcon_get_intval(type); is_partial = (i_type == PHALCON_MVC_MODEL_RESULTSET_TYPE_PARTIAL); type = NULL; PHALCON_INIT_VAR(row); if (is_partial) { /** * The result is bigger than 32 rows so it's retrieved one by one */ zval *result = phalcon_fetch_nproperty_this(this_ptr, SL("_result"), PH_NOISY TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_CALL_METHOD(&row, result, "fetch", result); } else { ZVAL_FALSE(row); } } else { /** * The full rows are dumped in this_ptr->rows */ zval *rows = phalcon_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(rows) == IS_ARRAY) { phalcon_array_get_current(row, rows); if (Z_TYPE_P(row) == IS_OBJECT) { zend_hash_move_forward(Z_ARRVAL_P(rows)); } } else { ZVAL_FALSE(row); } } /** * Valid records are arrays */ if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) { /** * The result type=1 so we need to build every row */ if (is_partial) { /** * Get current hydration mode */ zval *hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC); zval *columns_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC); int i_hydrate_mode = phalcon_get_intval(hydrate_mode); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(empty_str); ZVAL_EMPTY_STRING(empty_str); /** * Each row in a complex result is a Phalcon\Mvc\Model\Row instance */ PHALCON_INIT_VAR(active_row); switch (i_hydrate_mode) { case 0: object_init_ex(active_row, phalcon_mvc_model_row_ce); break; case 1: array_init(active_row); break; case 2: default: object_init(active_row); break; } /** * Create every record according to the column types */ /** * Set records as dirty state PERSISTENT by default */ PHALCON_INIT_VAR(dirty_state); ZVAL_LONG(dirty_state, 0); phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(alias, ah0, hp0); PHALCON_GET_HVALUE(column); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY); if (PHALCON_IS_STRING(type, "object")) { /** * Object columns are assigned column by column */ PHALCON_OBS_NVAR(source); phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY); PHALCON_OBS_NVAR(attributes); phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY); PHALCON_OBS_NVAR(column_map); phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY); /** * Assign the values from the _source_attribute notation to its real column name */ PHALCON_INIT_NVAR(row_model); array_init(row_model); phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(attribute); /** * Columns are supposed to be in the form _table_field */ PHALCON_INIT_NVAR(column_alias); PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute); PHALCON_OBS_NVAR(column_value); phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY); phalcon_array_update_zval(&row_model, attribute, column_value, PH_COPY | PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } /** * Generate the column value according to the hydration type */ switch (phalcon_get_intval(hydrate_mode)) { case 0: { zval *keep_snapshots, *instance; /** * Check if the resultset must keep snapshots */ if (!phalcon_array_isset_string_fetch(&keep_snapshots, column, SS("keepSnapshots"))) { keep_snapshots = PHALCON_GLOBAL(z_false); } /** * Get the base instance */ if (!phalcon_array_isset_string_fetch(&instance, column, SS("instance"))) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: instance"); instance = PHALCON_GLOBAL(z_null); } /** * Assign the values to the attributes using a column map */ PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots); break; } default: /** * Other kinds of hydrations */ PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", row_model, column_map, hydrate_mode); break; } /** * The complete object is assigned to an attribute with the name of the alias or * the model name */ PHALCON_OBS_NVAR(attribute); if (phalcon_array_isset_string(column, SS("balias"))) { phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY); } } else { /** * Scalar columns are simply assigned to the result object */ if (phalcon_array_isset_string(column, SS("sqlAlias"))) { PHALCON_OBS_NVAR(sql_alias); phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY); PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, row, sql_alias, PH_NOISY); } else { PHALCON_OBS_NVAR(value); if (phalcon_array_isset(row, alias)) { phalcon_array_fetch(&value, row, alias, PH_NOISY); } } /** * If a 'balias' is defined is not an unnamed scalar */ if (phalcon_array_isset_string(column, SS("balias"))) { PHALCON_CPY_WRT(attribute, alias); } else { PHALCON_INIT_NVAR(n_alias); phalcon_fast_str_replace(n_alias, underscore, empty_str, alias); PHALCON_CPY_WRT(attribute, n_alias); } assert(attribute != NULL); } /** * Assign the instance according to the hydration type */ if (unlikely(!attribute)) { zend_throw_exception_ex(phalcon_mvc_model_exception_ce, 0 TSRMLS_CC, "Unexpected inconsistency: attribute is NULL"); RETURN_MM(); } switch (phalcon_get_intval(hydrate_mode)) { case 1: phalcon_array_update_zval(&active_row, attribute, value, PH_COPY | PH_SEPARATE); break; default: phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC); break; } zend_hash_move_forward_ex(ah0, &hp0); } /** * Store the generated row in this_ptr->activeRow to be retrieved by 'current' */ phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); } else { /** * The row is already built so we just assign it to the activeRow */ phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC); } RETURN_MM_TRUE; } /** * There are no results to retrieve so we update this_ptr->activeRow as false */ phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); RETURN_MM_FALSE; }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, valid){ zval *type = NULL, *result = NULL, *row = NULL, *rows = NULL, *model = NULL, *active_row = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetcharray", result, PH_NO_CHECK); } else { PHALCON_INIT_VAR(row); ZVAL_BOOL(row, 0); } } else { PHALCON_INIT_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(rows); PHALCON_CALL_METHOD(rows, result, "fetchall", PH_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } if (Z_TYPE_P(rows) == IS_ARRAY) { Z_SET_ISREF_P(rows); PHALCON_INIT_VAR(row); PHALCON_CALL_FUNC_PARAMS_1(row, "current", rows); Z_UNSET_ISREF_P(rows); if (PHALCON_IS_NOT_FALSE(row)) { Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows); Z_UNSET_ISREF_P(rows); } } else { PHALCON_INIT_VAR(row); ZVAL_BOOL(row, 0); } } if (PHALCON_IS_NOT_FALSE(row)) { PHALCON_INIT_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); PHALCON_INIT_VAR(active_row); PHALCON_CALL_STATIC_PARAMS_2(active_row, "phalcon\\mvc\\model", "dumpresult", model, row); phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } else { phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){ zval *type = NULL, *result, *row = NULL, *rows, *underscore, *empty_str; zval *active_row, *columns_types, *column = NULL, *alias = NULL; zval *source = NULL, *instance = NULL, *attributes = NULL, *column_map = NULL; zval *row_model = NULL, *attribute = NULL, *column_alias = NULL, *value = NULL; zval *model_attribute = NULL, *sql_alias = NULL, *n_alias = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result, PH_NO_CHECK); } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } else { PHALCON_INIT_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); Z_SET_ISREF_P(rows); PHALCON_INIT_NVAR(row); PHALCON_CALL_FUNC_PARAMS_1(row, "current", rows); Z_UNSET_ISREF_P(rows); if (zend_is_true(row)) { Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows); Z_UNSET_ISREF_P(rows); } } if (PHALCON_IS_NOT_FALSE(row)) { PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(active_row); object_init_ex(active_row, phalcon_mvc_model_row_ce); PHALCON_INIT_VAR(columns_types); phalcon_read_property(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC); if (!phalcon_valid_foreach(columns_types TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns_types); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_KEY(alias, ah0, hp0); PHALCON_GET_FOREACH_VALUE(column); PHALCON_INIT_NVAR(type); phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(type, "object")) { /** * Object columns are assigned column by column */ PHALCON_INIT_NVAR(source); phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY_CC); PHALCON_INIT_NVAR(instance); phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY_CC); PHALCON_INIT_NVAR(attributes); phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY_CC); PHALCON_INIT_NVAR(column_map); phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY_CC); /** * Assign the values from the _source_attribute notation to its real column name */ PHALCON_INIT_NVAR(row_model); array_init(row_model); if (!phalcon_valid_foreach(attributes TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(attributes); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_GET_FOREACH_VALUE(attribute); PHALCON_INIT_NVAR(column_alias); PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute); PHALCON_INIT_NVAR(value); phalcon_array_fetch(&value, row, column_alias, PH_NOISY_CC); phalcon_array_update_zval(&row_model, attribute, &value, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: /** * Assign the values to the attributes using a column map */ PHALCON_INIT_NVAR(model_attribute); PHALCON_CALL_STATIC_PARAMS_3(model_attribute, "phalcon\\mvc\\model", "dumpresultmap", instance, row_model, column_map); /** * The complete object is assigned to an attribute with the name of the alias or * the model name */ PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY_CC); phalcon_update_property_zval_zval(active_row, attribute, model_attribute TSRMLS_CC); } else { /** * Scalar columns are simply assigned to the result object */ eval_int = phalcon_array_isset_string(column, SS("sqlAlias")); if (eval_int) { PHALCON_INIT_NVAR(sql_alias); phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY_CC); PHALCON_INIT_NVAR(value); phalcon_array_fetch(&value, row, sql_alias, PH_NOISY_CC); } else { PHALCON_INIT_NVAR(value); phalcon_array_fetch(&value, row, alias, PH_NOISY_CC); } /** * If a 'balias' is defined is not an unnamed scalar */ eval_int = phalcon_array_isset_string(column, SS("balias")); if (eval_int) { phalcon_update_property_zval_zval(active_row, alias, value TSRMLS_CC); } else { PHALCON_INIT_NVAR(n_alias); phalcon_fast_str_replace(n_alias, underscore, empty_str, alias TSRMLS_CC); phalcon_update_property_zval_zval(active_row, n_alias, value TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } else { phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Returns a slice of the resultset to show in the pagination * * @return \stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate) { zval show = {}, config = {}, items = {}, page_number = {}, rowcount = {}, page = {}, last_show_page = {}, start = {}, possible_pages = {}, total_pages = {}; zval page_items = {}, maximum_pages = {}, next = {}, additional_page = {}, before = {}, remainder = {}, pages_total = {}; long int i, i_show; phalcon_return_property(&show, getThis(), SL("_limitRows")); phalcon_return_property(&config, getThis(), SL("_config")); phalcon_return_property(&page_number, getThis(), SL("_page")); i_show = phalcon_get_intval(&show); phalcon_array_fetch_str(&items, &config, SL("data"), PH_NOISY); if (Z_TYPE(page_number) == IS_NULL || PHALCON_LT(&show, &PHALCON_GLOBAL(z_zero))) { PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one)); } phalcon_fast_count(&rowcount, &items); object_init(&page); phalcon_sub_function(&last_show_page, &page_number, &PHALCON_GLOBAL(z_one)); mul_function(&start, &show, &last_show_page); phalcon_div_function(&possible_pages, &rowcount, &show); if (unlikely(Z_TYPE(possible_pages)) != IS_DOUBLE) { convert_to_double(&possible_pages); } ZVAL_LONG(&total_pages, (long int)ceil(Z_DVAL(possible_pages))); if (Z_TYPE(items) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Invalid data for paginator"); return; } array_init(&page_items); if (PHALCON_GT(&rowcount, &PHALCON_GLOBAL(z_zero))) { /** * Seek to the desired position */ if (PHALCON_LT(&start, &rowcount)) { PHALCON_CALL_METHODW(NULL, &items, "seek", &start); } else { PHALCON_CALL_METHODW(NULL, &items, "rewind"); PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one)); PHALCON_CPY_WRT_CTOR(&start, &PHALCON_GLOBAL(z_zero)); } /** * The record must be iterable */ for (i=1; ; ++i) { zval valid = {}, current = {}; PHALCON_CALL_METHODW(&valid, &items, "valid"); if (!PHALCON_IS_NOT_FALSE(&valid)) { break; } PHALCON_CALL_METHODW(¤t, &items, "current"); phalcon_array_append(&page_items, ¤t, PH_COPY); if (i >= i_show) { break; } } } phalcon_update_property_zval(&page, SL("items"), &page_items); phalcon_add_function(&maximum_pages, &start, &show); if (PHALCON_LT(&maximum_pages, &rowcount)) { phalcon_add_function(&next, &page_number, &PHALCON_GLOBAL(z_one)); } else if (PHALCON_IS_EQUAL(&maximum_pages, &rowcount)) { PHALCON_CPY_WRT_CTOR(&next, &rowcount); } else { phalcon_div_function(&possible_pages, &rowcount, &show); phalcon_add_function(&additional_page, &possible_pages, &PHALCON_GLOBAL(z_one)); ZVAL_LONG(&next, phalcon_get_intval(&additional_page)); } if (PHALCON_GT(&next, &total_pages)) { PHALCON_CPY_WRT_CTOR(&next, &total_pages); } phalcon_update_property_zval(&page, SL("next"), &next); if (PHALCON_GT(&page_number, &PHALCON_GLOBAL(z_one))) { phalcon_sub_function(&before, &page_number, &PHALCON_GLOBAL(z_one)); } else { PHALCON_CPY_WRT_CTOR(&before, &PHALCON_GLOBAL(z_one)); } phalcon_update_property_zval(&page, SL("first"), &PHALCON_GLOBAL(z_one)); phalcon_update_property_zval(&page, SL("before"), &before); phalcon_update_property_zval(&page, SL("current"), &page_number); mod_function(&remainder, &rowcount, &show); phalcon_div_function(&possible_pages, &rowcount, &show); if (!PHALCON_IS_LONG(&remainder, 0)) { phalcon_add_function(&next, &possible_pages, &PHALCON_GLOBAL(z_one)); ZVAL_LONG(&pages_total, phalcon_get_intval(&next)); } else { PHALCON_CPY_WRT_CTOR(&pages_total, &possible_pages); } phalcon_update_property_zval(&page, SL("last"), &pages_total); phalcon_update_property_zval(&page, SL("total_pages"), &pages_total); phalcon_update_property_zval(&page, SL("total_items"), &rowcount); RETURN_CTORW(&page); }
/** * Handles a MVC request * * @param string $uri * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Mvc_Application, handle){ zval *uri = NULL, *dependency_injector, *events_manager; zval *event_name = NULL, *status = NULL, *service = NULL, *router, *module_name = NULL; zval *module_object = NULL, *modules, *exception_msg = NULL; zval *module, *class_name = NULL, *path, *module_params; zval *implicit_view, *view, *namespace_name; zval *controller_name = NULL, *action_name = NULL, *params = NULL; zval *dispatcher, *controller, *returned_response = NULL; zval *possible_response, *render_status = NULL, *response = NULL; zval *content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &uri); if (!uri) { PHALCON_INIT_VAR(uri); } 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_THROW_EXCEPTION_STR(phalcon_mvc_application_exception_ce, "A dependency injection object is required to access internal services"); return; } PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Call boot event, this allow the developer to perform initialization actions */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "application:boot", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "router", 1); PHALCON_INIT_VAR(router); phalcon_call_method_p1(router, dependency_injector, "getshared", service); /** * Handle the URI pattern (if any) */ phalcon_call_method_p1_noret(router, "handle", uri); /** * Load module config */ PHALCON_INIT_VAR(module_name); phalcon_call_method(module_name, router, "getmodulename"); /** * If the router doesn't return a valid module we use the default module */ if (!zend_is_true(module_name)) { PHALCON_OBS_NVAR(module_name); phalcon_read_property_this(&module_name, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } PHALCON_INIT_VAR(module_object); /** * Process the module definition */ if (zend_is_true(module_name)) { if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeStartModule", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, module_name); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Check if the module passed by the router is registered in the modules container */ PHALCON_OBS_VAR(modules); phalcon_read_property_this(&modules, this_ptr, SL("_modules"), PH_NOISY_CC); if (!phalcon_array_isset(modules, module_name)) { PHALCON_INIT_VAR(exception_msg); PHALCON_CONCAT_SVS(exception_msg, "Module '", module_name, "' isn't registered in the application container"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_application_exception_ce, exception_msg); return; } /** * A module definition must ne an array or an object */ PHALCON_OBS_VAR(module); phalcon_array_fetch(&module, modules, module_name, PH_NOISY); if (Z_TYPE_P(module) != IS_ARRAY) { if (Z_TYPE_P(module) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_application_exception_ce, "Invalid module definition"); return; } } /** * An array module definition contains a path to a module definition class */ if (Z_TYPE_P(module) == IS_ARRAY) { /** * Class name used to load the module definition */ if (phalcon_array_isset_string(module, SS("className"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_string(&class_name, module, SL("className"), PH_NOISY); } else { PHALCON_INIT_NVAR(class_name); ZVAL_STRING(class_name, "Module", 1); } /** * If developer specify a path try to include the file */ if (phalcon_array_isset_string(module, SS("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_string(&path, module, SL("path"), PH_NOISY); if (!phalcon_class_exists(class_name, 0 TSRMLS_CC)) { if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) { if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } } else { PHALCON_INIT_NVAR(exception_msg); PHALCON_CONCAT_SVS(exception_msg, "Module definition path '", path, "' doesn't exist"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_application_exception_ce, exception_msg); return; } } } phalcon_call_method_p1(module_object, dependency_injector, "get", class_name); /** * 'registerAutoloaders' and 'registerServices' are automatically called */ phalcon_call_method_p1_noret(module_object, "registerautoloaders", dependency_injector); phalcon_call_method_p1_noret(module_object, "registerservices", dependency_injector); } else { /** * A module definition object, can be a Closure instance */ if (phalcon_is_instance_of(module, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(module_params); array_init_size(module_params, 1); phalcon_array_append(&module_params, dependency_injector, PH_SEPARATE); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, module, module_params); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_application_exception_ce, "Invalid module definition"); return; } } /** * Calling afterStartModule event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_moduleObject"), module_object TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:afterStartModule", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, module_name); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } } /** * Check whether use implicit views or not */ PHALCON_OBS_VAR(implicit_view); phalcon_read_property_this(&implicit_view, this_ptr, SL("_implicitView"), PH_NOISY_CC); if (PHALCON_IS_TRUE(implicit_view)) { PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "view", 1); PHALCON_INIT_VAR(view); phalcon_call_method_p1(view, dependency_injector, "getshared", service); } /** * We get the parameters from the router and assign them to the dispatcher */ PHALCON_INIT_NVAR(module_name); phalcon_call_method(module_name, router, "getmodulename"); PHALCON_INIT_VAR(namespace_name); phalcon_call_method(namespace_name, router, "getnamespacename"); PHALCON_INIT_VAR(controller_name); phalcon_call_method(controller_name, router, "getcontrollername"); PHALCON_INIT_VAR(action_name); phalcon_call_method(action_name, router, "getactionname"); PHALCON_INIT_VAR(params); phalcon_call_method(params, router, "getparams"); PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "dispatcher", 1); PHALCON_INIT_VAR(dispatcher); phalcon_call_method_p1(dispatcher, dependency_injector, "getshared", service); /** * Assign the values passed from the router */ phalcon_call_method_p1_noret(dispatcher, "setmodulename", module_name); phalcon_call_method_p1_noret(dispatcher, "setnamespacename", namespace_name); phalcon_call_method_p1_noret(dispatcher, "setcontrollername", controller_name); phalcon_call_method_p1_noret(dispatcher, "setactionname", action_name); phalcon_call_method_p1_noret(dispatcher, "setparams", params); /** * Start the view component (start output buffering) */ if (PHALCON_IS_TRUE(implicit_view)) { phalcon_call_method_noret(view, "start"); } /** * Calling beforeHandleRequest */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeHandleRequest", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, dispatcher); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * The dispatcher must return an object */ PHALCON_INIT_VAR(controller); phalcon_call_method(controller, dispatcher, "dispatch"); PHALCON_INIT_VAR(returned_response); ZVAL_BOOL(returned_response, 0); /** * Get the latest value returned by an action */ PHALCON_INIT_VAR(possible_response); phalcon_call_method(possible_response, dispatcher, "getreturnedvalue"); if (Z_TYPE_P(possible_response) == IS_OBJECT) { /** * Check if the returned object is already a response */ phalcon_instance_of(returned_response, possible_response, phalcon_http_responseinterface_ce TSRMLS_CC); } /** * Calling afterHandleRequest */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:afterHandleRequest", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, controller); } /** * If the dispatcher returns an object we try to render the view in auto-rendering * mode */ if (PHALCON_IS_FALSE(returned_response)) { if (PHALCON_IS_TRUE(implicit_view)) { if (Z_TYPE_P(controller) == IS_OBJECT) { PHALCON_INIT_VAR(render_status); ZVAL_BOOL(render_status, 1); /** * This allows to make a custom view render */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:viewRender", 1); phalcon_call_method_p3(render_status, events_manager, "fire", event_name, this_ptr, view); } /** * Check if the view process has been treated by the developer */ if (PHALCON_IS_NOT_FALSE(render_status)) { PHALCON_INIT_NVAR(controller_name); phalcon_call_method(controller_name, dispatcher, "getcontrollername"); PHALCON_INIT_NVAR(action_name); phalcon_call_method(action_name, dispatcher, "getactionname"); PHALCON_INIT_NVAR(params); phalcon_call_method(params, dispatcher, "getparams"); /** * Automatic render based on the latest controller executed */ phalcon_call_method_p3_noret(view, "render", controller_name, action_name, params); } } } } /** * Finish the view component (stop output buffering) */ if (PHALCON_IS_TRUE(implicit_view)) { phalcon_call_method_noret(view, "finish"); } if (PHALCON_IS_FALSE(returned_response)) { PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "response", 1); PHALCON_INIT_VAR(response); phalcon_call_method_p1(response, dependency_injector, "getshared", service); if (PHALCON_IS_TRUE(implicit_view)) { /** * The content returned by the view is passed to the response service */ PHALCON_INIT_VAR(content); phalcon_call_method(content, view, "getcontent"); phalcon_call_method_p1_noret(response, "setcontent", content); } } else { /** * We don't need to create a response because there is a one already created */ PHALCON_CPY_WRT(response, possible_response); } /** * Calling beforeSendResponse */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeSendResponse", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, response); } /** * Headers are automatically send */ phalcon_call_method_noret(response, "sendheaders"); /** * Cookies are automatically send */ phalcon_call_method_noret(response, "sendcookies"); /** * Return the response */ RETURN_CCTOR(response); }
/** * Executes render process from dispatching data * *<code> * $view->start(); * //Shows recent posts view (app/views/posts/recent.phtml) * $view->render('posts', 'recent'); * $view->finish(); *</code> * * @param string $controllerName * @param string $actionName * @param array $params */ PHP_METHOD(Phalcon_Mvc_View, render){ zval *controller_name, *action_name, *params = NULL; zval *disabled, *contents = NULL, *layouts_dir = NULL, *layout; zval *layout_name = NULL, *engines, *pick_view, *render_view = NULL; zval *pick_view_action, *cache = NULL, *cache_level; zval *events_manager, *event_name = NULL, *status, *must_clean; zval *silence = NULL, *disabled_levels, *render_level; zval *enter_level = NULL, *templates_before, *template_before = NULL; zval *view_temp_path = NULL, *templates_after, *template_after = NULL; zval *main_view, *is_started, *is_fresh; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &controller_name, &action_name, ¶ms); if (!params) { PHALCON_INIT_VAR(params); } /** * If the view is disabled we simply update the buffer from any output produced in * the controller */ PHALCON_OBS_VAR(disabled); phalcon_read_property_this(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(disabled)) { PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC); RETURN_MM_FALSE; } phalcon_update_property_this(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_actionName"), action_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); /** * Check if there is a layouts directory set */ PHALCON_OBS_VAR(layouts_dir); phalcon_read_property_this(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC); if (!zend_is_true(layouts_dir)) { PHALCON_INIT_NVAR(layouts_dir); ZVAL_STRING(layouts_dir, "layouts/", 1); } /** * Check if the user has defined a custom layout */ PHALCON_OBS_VAR(layout); phalcon_read_property_this(&layout, this_ptr, SL("_layout"), PH_NOISY_CC); if (zend_is_true(layout)) { PHALCON_CPY_WRT(layout_name, layout); } else { PHALCON_CPY_WRT(layout_name, controller_name); } /** * Load the template engines */ PHALCON_INIT_VAR(engines); PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines"); /** * Check if the user has picked a view diferent than the automatic */ PHALCON_OBS_VAR(pick_view); phalcon_read_property_this(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC); if (Z_TYPE_P(pick_view) == IS_NULL) { PHALCON_INIT_VAR(render_view); PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name); } else { /** * The 'picked' view is an array, where the first element is controller and the * second the action */ PHALCON_OBS_NVAR(render_view); phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC); if (phalcon_array_isset_long(pick_view, 1)) { PHALCON_OBS_VAR(pick_view_action); phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC); PHALCON_CPY_WRT(layout_name, pick_view_action); } } PHALCON_INIT_VAR(cache); /** * Start the cache if there is a cache level enabled */ PHALCON_OBS_VAR(cache_level); phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC); if (zend_is_true(cache_level)) { PHALCON_CALL_METHOD(cache, this_ptr, "getcache"); } PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); /** * Call beforeRender if there is an events manager */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "view:beforeRender", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Get the current content in the buffer maybe some output from the controller */ PHALCON_INIT_NVAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC); PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 1); PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); /** * Disabled levels allow to avoid an specific level of rendering */ PHALCON_OBS_VAR(disabled_levels); phalcon_read_property_this(&disabled_levels, this_ptr, SL("_disabledLevels"), PH_NOISY_CC); /** * Render level will tell use when to stop */ PHALCON_OBS_VAR(render_level); phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC); if (zend_is_true(render_level)) { /** * Inserts view related to action */ PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 1)) { PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache); } } /** * Inserts templates before layout */ PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 2); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 2)) { PHALCON_OBS_VAR(templates_before); phalcon_read_property_this(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC); /** * Templates before must be an array */ if (Z_TYPE_P(templates_before) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_is_iterable(templates_before, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(template_before); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); zend_hash_move_forward_ex(ah0, &hp0); } ZVAL_BOOL(silence, 1); } } } /** * Inserts controller layout */ PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 3); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 3)) { PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, layout_name); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); } } /** * Inserts templates after layout */ PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 4); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 4)) { /** * Templates after must be an array */ PHALCON_OBS_VAR(templates_after); phalcon_read_property_this(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC); if (Z_TYPE_P(templates_after) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_is_iterable(templates_after, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(template_after); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); zend_hash_move_forward_ex(ah1, &hp1); } ZVAL_BOOL(silence, 1); } } } /** * Inserts main view */ PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 5); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 5)) { PHALCON_OBS_VAR(main_view); phalcon_read_property_this(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache); } } /** * Store the data in the cache */ if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_VAR(is_started); PHALCON_CALL_METHOD(is_started, cache, "isstarted"); if (PHALCON_IS_TRUE(is_started)) { PHALCON_INIT_VAR(is_fresh); PHALCON_CALL_METHOD(is_fresh, cache, "isfresh"); if (PHALCON_IS_TRUE(is_fresh)) { PHALCON_CALL_METHOD_NORETURN(cache, "save"); } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop"); } } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop"); } } } /** * Call afterRender event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRender", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } RETURN_MM_NULL(); }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){ zval *table, *schema = NULL, *columns, *dialect, *size_pattern; zval *sql, *fetch_assoc, *describe, *old_column = NULL; zval *field = NULL, *definition = NULL, *column_type = NULL, *pos = NULL, *attribute = NULL; zval *matches = NULL, *match_one = NULL, *column_name = NULL, *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_INIT_NVAR(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(size_pattern); ZVAL_STRING(size_pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_NVAR(definition); array_init(definition); add_assoc_long_ex(definition, SS("bindType"), 2); PHALCON_INIT_NVAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_NVAR(pos); phalcon_fast_stripos_str(pos, column_type, SL("int") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(pos)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } } else { if (phalcon_memnstr_str(column_type, SL("varchar") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("date") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("decimal") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("char") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("datetime") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("text") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("float") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("enum") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } } } } } } } } } if (phalcon_memnstr_str(column_type, SL("(") TSRMLS_CC)) { PHALCON_INIT_NVAR(matches); array_init(matches); Z_SET_ISREF_P(matches); PHALCON_INIT_NVAR(pos); PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", size_pattern, column_type, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(pos)) { eval_int = phalcon_array_isset_long(matches, 1); if (eval_int) { PHALCON_INIT_NVAR(match_one); phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } if (phalcon_memnstr_str(column_type, SL("unsigned") TSRMLS_CC)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (!zend_is_true(old_column)) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC); PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(columns); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router, handle) { zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL; zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL; zval *route = NULL, *methods = NULL, *dependency_injector = NULL; zval *service = NULL, *match_method = NULL, *pattern = NULL, *have_parenthesis = NULL; zval *paths = NULL, *position = NULL, *part = NULL, *match_position = NULL; zval *module = NULL, *default_module = NULL, *controller = NULL, *default_controller = NULL; zval *action = NULL, *default_action = NULL, *params_str = NULL, *one = NULL; zval *str_params = NULL, *slash = NULL, *params_merge = NULL, *default_params = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_ALLOC_ZVAL_MM(uri); ZVAL_NULL(uri); } if (!zend_is_true(uri)) { PHALCON_INIT_VAR(real_uri); PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_INIT_VAR(request); ZVAL_NULL(request); PHALCON_INIT_VAR(route_found); ZVAL_BOOL(route_found, 0); PHALCON_INIT_VAR(parts); array_init(parts); PHALCON_INIT_VAR(params); array_init(params); PHALCON_INIT_VAR(matches); ZVAL_NULL(matches); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); PHALCON_INIT_VAR(routes); phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC); PHALCON_INIT_VAR(reversed_routes); PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes); if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(reversed_routes); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(route); PHALCON_INIT_VAR(methods); PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK); if (Z_TYPE_P(methods) != IS_NULL) { if (Z_TYPE_P(request) == IS_NULL) { PHALCON_INIT_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "request", 1); PHALCON_INIT_VAR(request); PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", service, PH_NO_CHECK); } PHALCON_INIT_VAR(match_method); PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK); if (PHALCON_IS_FALSE(match_method)) { zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; } } PHALCON_INIT_VAR(pattern); PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK); PHALCON_INIT_VAR(have_parenthesis); phalcon_fast_strpos_str(have_parenthesis, pattern, SL("(") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(have_parenthesis)) { Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(route_found); PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches); Z_UNSET_ISREF_P(matches); } else { PHALCON_INIT_VAR(route_found); is_equal_function(route_found, pattern, real_uri TSRMLS_CC); } if (zend_is_true(route_found)) { PHALCON_INIT_VAR(paths); PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK); PHALCON_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { if (!phalcon_valid_foreach(paths TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(paths); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_INIT_VAR(part); PHALCON_GET_FOREACH_KEY(part, ah1, hp1); PHALCON_GET_FOREACH_VALUE(position); eval_int = phalcon_array_isset(matches, position); if (eval_int) { PHALCON_INIT_VAR(match_position); phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC); phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); goto ph_cycle_end_0; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if (zend_is_true(route_found)) { eval_int = phalcon_array_isset_string(parts, SL("module")+1); if (eval_int) { PHALCON_INIT_VAR(module); phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("module")+1); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_INIT_VAR(controller); phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("controller")+1); } else { PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_INIT_VAR(action); phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("action")+1); } else { PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("params")+1); if (eval_int) { PHALCON_INIT_VAR(params_str); phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC); PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(str_params); PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, one); if (zend_is_true(str_params)) { PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); PHALCON_INIT_VAR(params); phalcon_fast_explode(params, slash, str_params TSRMLS_CC); } PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("params")+1); } PHALCON_INIT_VAR(params_merge); PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts); phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); PHALCON_INIT_VAR(default_params); phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, valid){ zval *type, *result = NULL, *row = NULL, *rows = NULL, *dirty_state, *hydrate_mode; zval *keep_snapshots, *column_map, *model, *active_row = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (Z_TYPE_P(result) == IS_OBJECT) { PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result); } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } else { PHALCON_OBS_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) != IS_ARRAY) { PHALCON_OBS_NVAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (Z_TYPE_P(result) == IS_OBJECT) { PHALCON_INIT_NVAR(rows); PHALCON_CALL_METHOD(rows, result, "fetchall"); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } if (Z_TYPE_P(rows) == IS_ARRAY) { PHALCON_INIT_NVAR(row); phalcon_array_get_current(row, rows TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(row)) { phalcon_array_next(rows); } } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } if (Z_TYPE_P(row) != IS_ARRAY) { phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); RETURN_MM_FALSE; } /** * Set records as dirty state PERSISTENT by default */ PHALCON_INIT_VAR(dirty_state); ZVAL_LONG(dirty_state, 0); /** * Get current hydration mode */ PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); /** * Tell if the resultset is keeping snapshots */ PHALCON_OBS_VAR(keep_snapshots); phalcon_read_property(&keep_snapshots, this_ptr, SL("_keepSnapshots"), PH_NOISY_CC); /** * Get the resultset column map */ PHALCON_OBS_VAR(column_map); phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC); /** * Hydrate based on the current hydration */ switch (phalcon_get_intval(hydrate_mode)) { case 0: /** * this_ptr->model is the base entity */ PHALCON_OBS_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); /** * Performs the standard hydration based on objects */ PHALCON_INIT_VAR(active_row); PHALCON_CALL_STATIC_PARAMS_5(active_row, "phalcon\\mvc\\model", "cloneresultmap", model, row, column_map, dirty_state, keep_snapshots); break; default: /** * Other kinds of hydrations */ PHALCON_INIT_NVAR(active_row); PHALCON_CALL_STATIC_PARAMS_3(active_row, "phalcon\\mvc\\model", "cloneresultmaphydrate", row, column_map, hydrate_mode); break; } phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); RETURN_MM_TRUE; }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) { zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL; zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL; zval *char_size = NULL, *numeric_size = NULL, *column_type = NULL; zval *status = NULL, *attribute = NULL, *column_name = NULL, *column = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, t0, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); ZVAL_NULL(old_column); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_VAR(definition); array_init(definition); PHALCON_INIT_VAR(char_size); phalcon_array_fetch_string(&char_size, field, SL("size"), PH_NOISY_CC); PHALCON_INIT_VAR(numeric_size); phalcon_array_fetch_string(&numeric_size, field, SL("numericsize"), PH_NOISY_CC); PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("varying") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } } } } } } } PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (Z_TYPE_P(old_column) == IS_NULL) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC); PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(columns); }
/** * Executes render process from dispatching data * *<code> * $view->start(); * //Shows recent posts view (app/views/posts/recent.phtml) * $view->render('posts', 'recent'); * $view->finish(); *</code> * * @param string $controllerName * @param string $actionName * @param array $params */ PHP_METHOD(Phalcon_Mvc_View, render){ zval *controller_name, *action_name, *params = NULL; zval *disabled, *layouts_dir = NULL, *engines, *pick_view; zval *render_view = NULL, *render_controller = NULL, *pick_view_action; zval *cache = NULL, *cache_level, *events_manager, *event_name = NULL; zval *status, *contents, *must_clean, *silence = NULL; zval *render_level, *enter_level = NULL, *templates_before; zval *template_before = NULL, *view_temp_path = NULL, *templates_after; zval *template_after = NULL, *main_view, *is_started; zval *is_fresh; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!params) { PHALCON_INIT_NVAR(params); array_init(params); } PHALCON_INIT_VAR(disabled); phalcon_read_property(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(disabled)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } PHALCON_INIT_VAR(layouts_dir); phalcon_read_property(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC); if (!zend_is_true(layouts_dir)) { PHALCON_INIT_NVAR(layouts_dir); ZVAL_STRING(layouts_dir, "layouts/", 1); } phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); PHALCON_INIT_VAR(engines); PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines", PH_NO_CHECK); PHALCON_INIT_VAR(pick_view); phalcon_read_property(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC); if (Z_TYPE_P(pick_view) == IS_NULL) { PHALCON_INIT_VAR(render_view); PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name); PHALCON_CPY_WRT(render_controller, controller_name); } else { PHALCON_INIT_NVAR(render_view); phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC); eval_int = phalcon_array_isset_long(pick_view, 1); if (eval_int) { PHALCON_INIT_VAR(pick_view_action); phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC); PHALCON_CPY_WRT(render_controller, pick_view_action); } else { PHALCON_CPY_WRT(render_controller, controller_name); } } PHALCON_INIT_VAR(cache); PHALCON_INIT_VAR(cache_level); phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC); if (zend_is_true(cache_level)) { PHALCON_CALL_METHOD(cache, this_ptr, "getcache", PH_NO_CHECK); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "view:beforeRender", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK); if (PHALCON_IS_FALSE(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_zval(this_ptr, SL("_content"), contents TSRMLS_CC); PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 1); PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); PHALCON_INIT_VAR(render_level); phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC); if (zend_is_true(render_level)) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache, PH_NO_CHECK); } PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 2); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { PHALCON_INIT_VAR(templates_before); phalcon_read_property(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC); if (Z_TYPE_P(templates_before) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_valid_foreach(templates_before TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(templates_before); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(template_before); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: ZVAL_BOOL(silence, 1); } } PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 3); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, render_controller); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); } PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 4); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { PHALCON_INIT_VAR(templates_after); phalcon_read_property(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC); if (Z_TYPE_P(templates_after) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_valid_foreach(templates_after TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(templates_after); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_GET_FOREACH_VALUE(template_after); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: ZVAL_BOOL(silence, 1); } } PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 5); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { PHALCON_INIT_VAR(main_view); phalcon_read_property(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache, PH_NO_CHECK); } if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_VAR(is_started); PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK); if (PHALCON_IS_TRUE(is_started)) { PHALCON_INIT_VAR(is_fresh); PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK); if (PHALCON_IS_TRUE(is_fresh)) { PHALCON_CALL_METHOD_NORETURN(cache, "save", PH_NO_CHECK); } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop", PH_NO_CHECK); } } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop", PH_NO_CHECK); } } } if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRender", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }