/**
* Reads the complete meta-data for certain model
*
*<code>
* print_r(
* $metaData->readMetaData(
* new Robots()
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaData) {
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *source = NULL, *schema = NULL, *key = NULL, *_0, *_1, *_2, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(key);
ZEPHIR_CONCAT_VSVV(key, _0, "-", schema, source);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(_1, key))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, key, source, schema);
zephir_check_call_status();
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY_CC);
zephir_array_fetch(&_3, _2, key, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 254 TSRMLS_CC);
RETURN_CTOR(_3);
}
PHP_METHOD(PhalconPlus_Enum_AbstractEnum, __construct) {
zephir_fcall_cache_entry *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *val = NULL, *reflection = NULL, *defaultVal = NULL, *_0, *_1 = NULL, *_2, *_3$$3, *_4$$3 = NULL, *_5$$4, *_6$$4, _7$$4, *_8$$4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &val);
if (!val) {
ZEPHIR_INIT_VAR(val);
ZVAL_STRING(val, "__PhalconPlus_AbstractEnum_DefaultValue__", 1);
}
ZEPHIR_INIT_VAR(reflection);
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_INIT_VAR(_0);
zephir_get_called_class(_0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 4, _0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "__default", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, reflection, "hasconstant", NULL, 11, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (zephir_is_true(_1)) {
ZEPHIR_INIT_VAR(_3$$3);
ZVAL_STRING(_3$$3, "__default", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&defaultVal, reflection, "getconstant", NULL, 12, _3$$3);
zephir_check_temp_parameter(_3$$3);
zephir_check_call_status();
ZEPHIR_CALL_STATIC(&_4$$3, "isvalid", NULL, 0, defaultVal);
zephir_check_call_status();
if (!(zephir_is_true(_4$$3))) {
ZEPHIR_INIT_VAR(_5$$4);
object_init_ex(_5$$4, spl_ce_OutOfRangeException);
ZEPHIR_INIT_VAR(_6$$4);
zephir_get_class(_6$$4, this_ptr, 0 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_7$$4);
ZVAL_STRING(&_7$$4, "Invalid __default enumeration %s for Enum %s", 0);
ZEPHIR_CALL_FUNCTION(&_8$$4, "sprintf", NULL, 13, &_7$$4, defaultVal, _6$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _5$$4, "__construct", NULL, 14, _8$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_5$$4, "phalconplus/Enum/AbstractEnum.zep", 15 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
if (ZEPHIR_IS_STRING(val, "__PhalconPlus_AbstractEnum_DefaultValue__")) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setvalue", &_9, 0, defaultVal);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setvalue", &_9, 0, val);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Sets a connection service for a specific model
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, setConnectionService) {
zval *connectionService = NULL;
zval *model, *connectionService_param = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &connectionService_param);
if (unlikely(Z_TYPE_P(connectionService_param) != IS_STRING && Z_TYPE_P(connectionService_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'connectionService' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(connectionService_param) == IS_STRING)) {
zephir_get_strval(connectionService, connectionService_param);
} else {
ZEPHIR_INIT_VAR(connectionService);
ZVAL_EMPTY_STRING(connectionService);
}
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 0 TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("_connectionServices"), _0, connectionService TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(PhalconPlus_Enum_AbstractEnum, setValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *val, *_0 = NULL, *_1$$3, *_2$$3, _3$$3, *_4$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &val);
ZEPHIR_CALL_STATIC(&_0, "isvalid", NULL, 0, val);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(_1$$3);
object_init_ex(_1$$3, spl_ce_InvalidArgumentException);
ZEPHIR_INIT_VAR(_2$$3);
zephir_get_class(_2$$3, this_ptr, 0 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_3$$3);
ZVAL_STRING(&_3$$3, "Invalid enumeration %s for Enum %s", 0);
ZEPHIR_CALL_FUNCTION(&_4$$3, "sprintf", NULL, 13, &_3$$3, val, _2$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 15, _4$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$3, "phalconplus/Enum/AbstractEnum.zep", 29 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_update_property_this(this_ptr, SL("val"), val TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Reads meta-data for certain model
*
*<code>
* print_r(
* $metaData->readMetaDataIndex(
* new Robots(),
* 0
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaDataIndex) {
int index, ZEPHIR_LAST_CALL_STATUS;
zval *model, *index_param = NULL, *source = NULL, *schema = NULL, *key = NULL, *_0, *_1, *_2, *_3, *_4, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(key);
ZEPHIR_CONCAT_VSVV(key, _0, "-", schema, source);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY_CC);
zephir_array_fetch(&_2, _1, key, PH_READONLY, "phalcon/mvc/model/metadata.zep", 281 TSRMLS_CC);
if (!(zephir_array_isset_long(_2, index))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, key, source, schema);
zephir_check_call_status();
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY_CC);
zephir_array_fetch(&_4, _3, key, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 285 TSRMLS_CC);
zephir_array_fetch_long(&_5, _4, index, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 285 TSRMLS_CC);
RETURN_CTOR(_5);
}
/**
* Reads the ordered/reversed column map for certain model
*
*<code>
* print_r($metaData->readColumnMap(new Robots()));
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMap) {
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *keyName, *data = NULL, *_0, *_1, *_2, *_3, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(keyName);
zephir_get_class(keyName, model, 1 TSRMLS_CC);
ZEPHIR_OBS_VAR(data);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&data, _0, keyName, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_1);
ZVAL_NULL(_1);
ZEPHIR_INIT_VAR(_2);
ZVAL_NULL(_2);
ZEPHIR_INIT_VAR(_3);
ZVAL_NULL(_3);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, _1, _2, _3);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(data);
zephir_array_fetch(&data, _4, keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 329 TSRMLS_CC);
}
RETURN_CCTOR(data);
}
/**
* Reads column-map information for certain model using a MODEL_* constant
*
*<code>
* print_r(
* $metaData->readColumnMapIndex(
* new Robots(),
* MetaData::MODELS_REVERSE_COLUMN_MAP
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMapIndex) {
int index, ZEPHIR_LAST_CALL_STATUS;
zval *model, *index_param = NULL, *keyName = NULL, *columnMapModel = NULL, *map = NULL, *_0, *_1$$4, *_2$$4, *_3$$4, *_4$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(keyName);
zephir_get_class(keyName, model, 1 TSRMLS_CC);
ZEPHIR_OBS_VAR(columnMapModel);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&columnMapModel, _0, keyName, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_NULL(_1$$4);
ZEPHIR_INIT_VAR(_2$$4);
ZVAL_NULL(_2$$4);
ZEPHIR_INIT_VAR(_3$$4);
ZVAL_NULL(_3$$4);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, _1$$4, _2$$4, _3$$4);
zephir_check_call_status();
_4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(columnMapModel);
zephir_array_fetch(&columnMapModel, _4$$4, keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 378 TSRMLS_CC);
}
zephir_array_isset_long_fetch(&map, columnMapModel, index, 1 TSRMLS_CC);
RETURN_CTOR(map);
}
/**
* Initializes a model in the models manager
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, initialize) {
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *className, *initialized, *eventsManager, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, model, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(initialized);
zephir_read_property_this(&initialized, this_ptr, SL("_initialized"), PH_NOISY_CC);
if (!(zephir_array_isset(initialized, className))) {
if ((zephir_method_exists_ex(model, SS("initialize") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, model, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "collectionManager:afterInitialize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _0, model);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_initialized"), className, model TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_lastInitialized"), model TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Produces an string representation of a variable
*/
PHP_METHOD(Phalcon_Debug, _getVarDump) {
zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *variable, *className, *dumpedObject = NULL, *dump, *_0 = NULL, *_2 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &variable);
ZEPHIR_CALL_FUNCTION(&_0, "is_scalar", &_1, variable);
zephir_check_call_status();
if (zephir_is_true(_0)) {
if (Z_TYPE_P(variable) == IS_BOOL) {
if (zephir_is_true(variable)) {
RETURN_MM_STRING("true", 1);
} else {
RETURN_MM_STRING("false", 1);
}
}
if (Z_TYPE_P(variable) == IS_STRING) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_escapestring", NULL, variable);
zephir_check_call_status();
RETURN_MM();
}
RETVAL_ZVAL(variable, 1, 0);
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_OBJECT) {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, variable, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(dump);
if ((zephir_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&dumpedObject, variable, "dump", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, dumpedObject);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(dump, "Object(", className, ": ", _2, ")");
} else {
ZEPHIR_CONCAT_SVS(dump, "Object(", className, ")</span>");
}
RETURN_CCTOR(dump);
}
if (Z_TYPE_P(variable) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, variable);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "Array(", _2, ")");
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_NULL) {
RETURN_MM_STRING("null", 1);
}
zephir_gettype(return_value, variable TSRMLS_CC);
RETURN_MM();
}
/**
* Dispatch a event to the listeners and behaviors
* This method expects that the endpoint listeners/behaviors returns true
* meaning that a least one was implemented
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, missingMethod) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *eventName = NULL, *_4;
zval *model, *eventName_param = NULL, *data, *behaviors, *modelsBehaviors, *result = NULL, *eventsManager, *behavior = NULL, *_0, **_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &model, &eventName_param, &data);
if (unlikely(Z_TYPE_P(eventName_param) != IS_STRING && Z_TYPE_P(eventName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'eventName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(eventName_param) == IS_STRING)) {
zephir_get_strval(eventName, eventName_param);
} else {
ZEPHIR_INIT_VAR(eventName);
ZVAL_EMPTY_STRING(eventName);
}
ZEPHIR_OBS_VAR(behaviors);
zephir_read_property_this(&behaviors, this_ptr, SL("_behaviors"), PH_NOISY_CC);
if (Z_TYPE_P(behaviors) == IS_ARRAY) {
ZEPHIR_OBS_VAR(modelsBehaviors);
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 1 TSRMLS_CC);
if (zephir_array_isset_fetch(&modelsBehaviors, behaviors, _0, 0 TSRMLS_CC)) {
zephir_is_iterable(modelsBehaviors, &_2, &_1, 0, 0, "phalcon/mvc/collection/manager.zep", 325);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(behavior, _3);
ZEPHIR_CALL_METHOD(&result, behavior, "missingmethod", NULL, 0, model, eventName, data);
zephir_check_call_status();
if (Z_TYPE_P(result) != IS_NULL) {
RETURN_CCTOR(result);
}
}
}
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_SV(_4, "model:", eventName);
ZEPHIR_RETURN_CALL_METHOD(eventsManager, "fire", NULL, 0, _4, model, data);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_BOOL(0);
}
/**
* Validates a value against the class constants.
*
* If value is a valid constant name, returns the corresponding value.
*
* If value is null and a default is set, returns the default value.
*
* @param mixed value
*
* @return mixed
*
* @throws \RuntimeException if value is null and no default exists, or if given an invalid value.
*/
PHP_METHOD(Xpl_Enum, filterValidateValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *value = NULL, *reflection = NULL, *constants = NULL, *_0, *_2 = NULL, *_1$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &value);
if (!value) {
ZEPHIR_CPY_WRT(value, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(value);
}
ZEPHIR_INIT_VAR(reflection);
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, this_ptr, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 63, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&constants, reflection, "getconstants", NULL, 100);
zephir_check_call_status();
if (Z_TYPE_P(value) == IS_NULL) {
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_string_fetch(&value, constants, SS("_default"), 0 TSRMLS_CC)) {
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_RuntimeException, "Missing value: no default exists", "xpl/enum.zep", 177);
return;
}
if (Z_TYPE_P(value) == IS_STRING) {
if (zephir_array_isset(constants, value)) {
zephir_array_fetch(&_1$$6, constants, value, PH_NOISY | PH_READONLY, "xpl/enum.zep", 183 TSRMLS_CC);
ZEPHIR_CPY_WRT(value, _1$$6);
}
if ((zephir_method_exists(this_ptr, value TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(this_ptr, value, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
}
ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 2, value, constants, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!(zephir_is_true(_2))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_RuntimeException, "Invalid enum value", "xpl/enum.zep", 193);
return;
}
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
/**
* Sets the expiration time for this cache item.
*
* @param \DateTimeInterface expiration
* The point in time after which the item MUST be considered expired.
* If null is passed explicitly, a default value MAY be used. If none is set,
* the value should be stored permanently or for as long as the
* implementation allows.
*
* @return \Xpl\Cache\Item The called object.
*/
PHP_METHOD(Xpl_Cache_Item, expiresAt) {
int ZEPHIR_LAST_CALL_STATUS;
zval *expiration, *_0$$3, *_1$$3, *_2$$3, *_3$$5 = NULL, *_4$$5, *_5$$5, *_6$$6, *_7$$6 = NULL, _8$$6, *_9$$6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &expiration);
if (Z_TYPE_P(expiration) == IS_NULL) {
ZEPHIR_INIT_VAR(_0$$3);
zephir_time(_0$$3);
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("defaultTtl"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2$$3);
zephir_add_function(_2$$3, _0$$3, _1$$3);
zephir_update_property_this(this_ptr, SL("expires"), _2$$3 TSRMLS_CC);
} else {
if (zephir_is_instance_of(expiration, SL("DateTimeInterface") TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_4$$5);
ZVAL_STRING(_4$$5, "U", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$5, expiration, "format", NULL, 0, _4$$5);
zephir_check_temp_parameter(_4$$5);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_5$$5);
ZVAL_LONG(_5$$5, zephir_get_intval(_3$$5));
zephir_update_property_this(this_ptr, SL("expires"), _5$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_6$$6);
object_init_ex(_6$$6, xpl_cache_invalidargumentexception_ce);
ZEPHIR_INIT_VAR(_7$$6);
if (Z_TYPE_P(expiration) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_7$$6);
zephir_get_class(_7$$6, expiration, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_7$$6);
zephir_gettype(_7$$6, expiration TSRMLS_CC);
}
ZEPHIR_SINIT_VAR(_8$$6);
ZVAL_STRING(&_8$$6, "Expiration date must be null or instance of DateTimeInterface, given: \"%s\".", 0);
ZEPHIR_CALL_FUNCTION(&_9$$6, "sprintf", NULL, 41, &_8$$6, _7$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _6$$6, "__construct", NULL, 42, _9$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$6, "xpl/cache/item.zep", 147 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
RETURN_THIS();
}
PHP_METHOD(Auryn_AbstractCachingReflector, getMethod) {
zend_class_entry *_3;
int ZEPHIR_LAST_CALL_STATUS;
zval *methodName = NULL;
zval *classNameOrInstance, *methodName_param = NULL, *className = NULL, *cacheKey, *reflectedMethod = NULL, *_0, *_1, *_2, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &classNameOrInstance, &methodName_param);
if (unlikely(Z_TYPE_P(methodName_param) != IS_STRING && Z_TYPE_P(methodName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'methodName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(methodName_param) == IS_STRING)) {
methodName = methodName_param;
} else {
ZEPHIR_INIT_VAR(methodName);
ZVAL_EMPTY_STRING(methodName);
}
if (Z_TYPE_P(classNameOrInstance) == IS_STRING) {
ZEPHIR_CPY_WRT(className, classNameOrInstance);
} else {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, classNameOrInstance, 0 TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, className);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strtolower(_1, methodName);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SVSV(cacheKey, "auryn.refls.methods.", _0, ".", _1);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedMethod, _2, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (!(zephir_is_true(reflectedMethod))) {
ZEPHIR_INIT_BNVAR(reflectedMethod);
_3 = zend_fetch_class(SL("ReflectionMethod"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(reflectedMethod, _3);
ZEPHIR_CALL_METHOD(NULL, reflectedMethod, "__construct", NULL, className, methodName);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _4, "store", NULL, cacheKey, reflectedMethod);
zephir_check_call_status();
}
RETURN_CCTOR(reflectedMethod);
}
/**
* Parses or retrieves all the annotations found in a class
*
* @param string|object className
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter, get) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
zend_bool _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *className, *annotations, *classAnnotations = NULL, *parsedAnnotations = NULL, *realClassName = NULL, *reader = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className);
if (Z_TYPE_P(className) == IS_OBJECT) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class(realClassName, className, 0 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(realClassName, className);
}
ZEPHIR_OBS_VAR(annotations);
zephir_read_property_this(&annotations, this_ptr, SL("_annotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) == IS_ARRAY) {
if (zephir_array_isset(annotations, realClassName)) {
zephir_array_fetch(&_0, annotations, realClassName, PH_NOISY | PH_READONLY, "phalcon/annotations/adapter.zep", 91 TSRMLS_CC);
RETURN_CTOR(_0);
}
}
ZEPHIR_CALL_METHOD(&classAnnotations, this_ptr, "read", NULL, realClassName);
zephir_check_call_status();
_1 = Z_TYPE_P(classAnnotations) == IS_NULL;
if (!(_1)) {
_1 = ZEPHIR_IS_FALSE_IDENTICAL(classAnnotations);
}
if (_1) {
ZEPHIR_CALL_METHOD(&reader, this_ptr, "getreader", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&parsedAnnotations, reader, "parse", NULL, realClassName);
zephir_check_call_status();
if (Z_TYPE_P(parsedAnnotations) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(classAnnotations);
object_init_ex(classAnnotations, phalcon_annotations_reflection_ce);
ZEPHIR_CALL_METHOD(NULL, classAnnotations, "__construct", &_2, parsedAnnotations);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_annotations"), realClassName, classAnnotations TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, realClassName, classAnnotations);
zephir_check_call_status();
}
}
RETURN_CCTOR(classAnnotations);
}
/**
* Writes meta-data for certain model using a MODEL_* constant
*
*<code>
* print_r(
* $metaData->writeColumnMapIndex(
* new Robots(),
* MetaData::MODELS_REVERSE_COLUMN_MAP,
* [
* "leName" => "name",
* ]
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, writeMetaDataIndex) {
zend_bool _0, _1;
zend_long index, ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *index_param = NULL, *data, data_sub, source, schema, key, _2, _3;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&data_sub);
ZVAL_UNDEF(&source);
ZVAL_UNDEF(&schema);
ZVAL_UNDEF(&key);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &model, &index_param, &data);
index = zephir_get_intval(index_param);
_0 = Z_TYPE_P(data) != IS_ARRAY;
if (_0) {
_0 = Z_TYPE_P(data) != IS_STRING;
}
_1 = _0;
if (_1) {
_1 = ((Z_TYPE_P(data) == IS_TRUE || Z_TYPE_P(data) == IS_FALSE) != 1);
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Invalid data for index", "phalcon/mvc/model/metadata.zep", 299);
return;
}
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_2);
zephir_get_class(&_2, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(&key);
ZEPHIR_CONCAT_VSVV(&key, &_2, "-", &schema, &source);
zephir_read_property(&_3, this_ptr, SL("_metaData"), PH_NOISY_CC | PH_READONLY);
if (!(zephir_array_isset(&_3, &key))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 5, model, &key, &source, &schema);
zephir_check_call_status();
}
zephir_update_property_array_multi(this_ptr, SL("_metaData"), data TSRMLS_CC, SL("zl"), 2, &key, index);
ZEPHIR_MM_RESTORE();
}
/**
* Sets a custom events manager for a specific model
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, setCustomEventsManager) {
zval *model, *eventsManager, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &eventsManager);
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 0 TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("_customEventsManager"), _0, eventsManager TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Appends a message to the validator
*
* @param string message
* @param string|array field
* @param string type
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator, appendMessage) {
int ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *field = NULL, *type = NULL, *_0 = NULL, _1, _2;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &message_param, &field, &type);
if (unlikely(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(message_param) == IS_STRING)) {
zephir_get_strval(message, message_param);
} else {
ZEPHIR_INIT_VAR(message);
ZVAL_EMPTY_STRING(message);
}
if (!field) {
field = ZEPHIR_GLOBAL(global_null);
}
if (!type) {
ZEPHIR_CPY_WRT(type, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(type);
}
if (!(zephir_is_true(type))) {
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, this_ptr, 0 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "Validator", 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
ZEPHIR_INIT_NVAR(type);
zephir_fast_str_replace(&type, &_1, &_2, _0 TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_mvc_model_message_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 296, message, field, type);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_messages"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Checks if a model is using implicit object ids
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, isUsingImplicitObjectIds) {
zval *model, *implicit, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_implicitObjectsIds"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
zephir_get_class(_1, model, 0 TSRMLS_CC);
if (zephir_array_isset_fetch(&implicit, _0, _1, 1 TSRMLS_CC)) {
RETURN_CTOR(implicit);
}
RETURN_MM_BOOL(1);
}
/**
* Writes meta-data for certain model using a MODEL_* constant
*
*<code>
* print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, writeMetaDataIndex) {
zend_bool _0, _1;
int index, ZEPHIR_LAST_CALL_STATUS;
zval *model, *index_param = NULL, *data, *metaData, *source = NULL, *schema = NULL, *key, *_2, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &model, &index_param, &data);
index = zephir_get_intval(index_param);
_0 = Z_TYPE_P(data) != IS_ARRAY;
if (_0) {
_0 = Z_TYPE_P(data) != IS_STRING;
}
_1 = _0;
if (_1) {
_1 = Z_TYPE_P(data) != IS_BOOL;
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Invalid data for index", "phalcon/mvc/model/metadata.zep", 291);
return;
}
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
zephir_get_class(_2, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(key);
ZEPHIR_CONCAT_VSVV(key, _2, "-", schema, source);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(_3, key))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, key, source, schema);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(metaData);
zephir_read_property_this(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC);
zephir_array_update_multi(&metaData, &data TSRMLS_CC, SL("zl"), 2, key, index);
zephir_update_property_this(this_ptr, SL("_metaData"), metaData TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Sets whether a model must use implicit objects ids
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, useImplicitObjectIds) {
zend_bool useImplicitObjectIds;
zval *model, *useImplicitObjectIds_param = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &useImplicitObjectIds_param);
useImplicitObjectIds = zephir_get_boolval(useImplicitObjectIds_param);
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_BOOL(_1, useImplicitObjectIds);
zephir_update_property_array(this_ptr, SL("_implicitObjectsIds"), _0, _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Reads meta-data for certain model
*
*<code>
* print_r(
* $metaData->readMetaDataIndex(
* new Robots(),
* 0
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaDataIndex) {
zend_long index, ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *index_param = NULL, source, schema, key, _0, _1, _2, _3, _4, _5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&source);
ZVAL_UNDEF(&schema);
ZVAL_UNDEF(&key);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_0);
zephir_get_class(&_0, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(&key);
ZEPHIR_CONCAT_VSVV(&key, &_0, "-", &schema, &source);
zephir_read_property(&_1, this_ptr, SL("_metaData"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_2, &_1, &key, PH_READONLY, "phalcon/mvc/model/metadata.zep", 272 TSRMLS_CC);
if (!(zephir_array_isset_long(&_2, index))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 5, model, &key, &source, &schema);
zephir_check_call_status();
}
zephir_read_property(&_3, this_ptr, SL("_metaData"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_4, &_3, &key, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 276 TSRMLS_CC);
zephir_array_fetch_long(&_5, &_4, index, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 276 TSRMLS_CC);
RETURN_CTOR(&_5);
}
/**
* Reads column-map information for certain model using a MODEL_* constant
*
*<code>
* print_r(
* $metaData->readColumnMapIndex(
* new Robots(),
* MetaData::MODELS_REVERSE_COLUMN_MAP
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMapIndex) {
zend_long index, ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *index_param = NULL, keyName, columnMapModel, map, _0, _1$$4, _2$$4, _3$$4;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&columnMapModel);
ZVAL_UNDEF(&map);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$4);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_3$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(&keyName);
zephir_get_class(&keyName, model, 1 TSRMLS_CC);
ZEPHIR_OBS_VAR(&columnMapModel);
zephir_read_property(&_0, this_ptr, SL("_columnMap"), PH_NOISY_CC | PH_READONLY);
if (!(zephir_array_isset_fetch(&columnMapModel, &_0, &keyName, 0 TSRMLS_CC))) {
ZVAL_NULL(&_1$$4);
ZVAL_NULL(&_2$$4);
ZVAL_NULL(&_3$$4);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 5, model, &_1$$4, &_2$$4, &_3$$4);
zephir_check_call_status();
zephir_read_property(&_1$$4, this_ptr, SL("_columnMap"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_OBS_NVAR(&columnMapModel);
zephir_array_fetch(&columnMapModel, &_1$$4, &keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 369 TSRMLS_CC);
}
zephir_array_isset_long_fetch(&map, &columnMapModel, index, 1 TSRMLS_CC);
RETURN_CTOR(&map);
}
/**
* Returns a custom events manager related to a model
*
* @param Phalcon\Mvc\CollectionInterface $model
* @return Phalcon\Events\ManagerInterface
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, getCustomEventsManager) {
zval *model, *customEventsManager, *className, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
ZEPHIR_OBS_VAR(customEventsManager);
zephir_read_property_this(&customEventsManager, this_ptr, SL("_customEventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(customEventsManager) == IS_ARRAY) {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, model, 1 TSRMLS_CC);
if (zephir_array_isset(customEventsManager, className)) {
zephir_array_fetch(&_0, customEventsManager, className, PH_NOISY | PH_READONLY, "phalcon/mvc/collection/manager.zep", 120 TSRMLS_CC);
RETURN_CTOR(_0);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Binds a behavior to a model
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, addBehavior) {
zval *model, *behavior, *entityName, *modelsBehaviors = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &behavior);
ZEPHIR_INIT_VAR(entityName);
zephir_get_class(entityName, model, 1 TSRMLS_CC);
ZEPHIR_OBS_VAR(modelsBehaviors);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_behaviors"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&modelsBehaviors, _0, entityName, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(modelsBehaviors);
array_init(modelsBehaviors);
}
zephir_array_append(&modelsBehaviors, behavior, PH_SEPARATE, "phalcon/mvc/collection/manager.zep", 358);
zephir_update_property_array(this_ptr, SL("_behaviors"), entityName, modelsBehaviors TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Returns the connection related to a model
*
* @param Phalcon\Mvc\CollectionInterface $model
* @return \Mongo
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, getConnection) {
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *service = NULL, *connectionService, *connection = NULL, *dependencyInjector, *entityName;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &model);
ZEPHIR_INIT_VAR(service);
ZVAL_STRING(service, "mongo", 1);
ZEPHIR_OBS_VAR(connectionService);
zephir_read_property_this(&connectionService, this_ptr, SL("_connectionServices"), PH_NOISY_CC);
if (Z_TYPE_P(connectionService) == IS_ARRAY) {
ZEPHIR_INIT_VAR(entityName);
zephir_get_class(entityName, model, 0 TSRMLS_CC);
if (zephir_array_isset(connectionService, entityName)) {
ZEPHIR_OBS_NVAR(service);
zephir_array_fetch(&service, connectionService, entityName, PH_NOISY, "phalcon/mvc/collection/manager.zep", 228 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/collection/manager.zep", 234);
return;
}
ZEPHIR_CALL_METHOD(&connection, dependencyInjector, "getshared", NULL, 0, service);
zephir_check_call_status();
if (Z_TYPE_P(connection) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "Invalid injected connection service", "phalcon/mvc/collection/manager.zep", 242);
return;
}
RETURN_CCTOR(connection);
}
PHP_METHOD(Phalcon_Validation_Validator_Uniqueness, isUniqueness) {
zval *_32$$16 = NULL, *_44$$20 = NULL, *_58$$25 = NULL;
zend_bool _11$$7, _18$$12;
zend_class_entry *_78;
HashTable *_2, *_8, *_24$$13, *_29$$15, *_41$$19, *_50$$22, *_55$$24, *_68$$27;
HashPosition _1, _7, _23$$13, _28$$15, _40$$19, _49$$22, _54$$24, _67$$27;
zephir_fcall_cache_entry *_5 = NULL, *_12 = NULL, *_14 = NULL;
int ZEPHIR_LAST_CALL_STATUS, index = 0;
zval *validation, *field = NULL, *value = NULL, *values = NULL, *convert = NULL, *record = NULL, *attribute = NULL, *except = NULL, *params = NULL, *metaData = NULL, *primaryField = NULL, *className = NULL, *singleField = NULL, *fieldExcept = NULL, *singleExcept = NULL, *notInValues = NULL, *exceptConditions = NULL, *_0 = NULL, **_3, **_9, *_63 = NULL, *_76, *_77 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_10$$7 = NULL, *_13$$7 = NULL, _15$$10 = zval_used_for_init, *_16$$10 = NULL, *_17$$11 = NULL, *_19$$12, _20$$12, _21$$12, *_22$$12 = NULL, **_25$$13, *_26$$14 = NULL, *_27$$14 = NULL, **_30$$15, *_33$$15 = NULL, *_34$$15 = NULL, _31$$16 = zval_used_for_init, _35$$17 = zval_used_for_init, *_36$$17 = NULL, *_37$$18 = NULL, *_38$$18, *_39$$18, **_42$$19, *_45$$19, *_46$$19, _43$$20 = zval_used_for_init, _47$$21, *_48$$21, **_51$$22, *_52$$23 = NULL, *_53$$23 = NULL, **_56$$24, *_59$$24 = NULL, *_60$$24 = NULL, _57$$25 = zval_used_for_init, _61$$26 = zval_used_for_init, *_62$$26 = NULL, *_64$$27 = NULL, *_65$$27, *_66$$27 = NULL, **_69$$27, *_70$$28 = NULL, _71$$28 = zval_used_for_init, *_72$$28 = NULL, *_73$$28 = NULL, *_74$$29, *_75$$29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_SEPARATE_PARAM(field);
ZEPHIR_INIT_VAR(exceptConditions);
array_init(exceptConditions);
index = 0;
ZEPHIR_INIT_VAR(params);
zephir_create_array(params, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("bind"), &_0, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(field) != IS_ARRAY) {
ZEPHIR_CPY_WRT(singleField, field);
ZEPHIR_INIT_NVAR(field);
array_init(field);
zephir_array_append(&field, singleField, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 156);
}
ZEPHIR_INIT_VAR(values);
array_init(values);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "convert", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&convert, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
zephir_is_iterable(field, &_2, &_1, 0, 0, "phalcon/validation/validator/uniqueness.zep", 166);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(singleField, _3);
ZEPHIR_CALL_METHOD(&_4$$4, validation, "getvalue", &_5, 0, singleField);
zephir_check_call_status();
zephir_array_update_zval(&values, singleField, &_4$$4, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(convert) != IS_NULL) {
ZEPHIR_CALL_ZVAL_FUNCTION(&_6$$5, convert, NULL, 0, values);
zephir_check_call_status();
ZEPHIR_CPY_WRT(values, _6$$5);
if (!(Z_TYPE_P(values) == IS_ARRAY)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Value conversion must return an array", "phalcon/validation/validator/uniqueness.zep", 170);
return;
}
}
zephir_is_iterable(field, &_8, &_7, 0, 0, "phalcon/validation/validator/uniqueness.zep", 200);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(singleField, _9);
ZEPHIR_INIT_NVAR(fieldExcept);
ZVAL_NULL(fieldExcept);
ZEPHIR_INIT_NVAR(notInValues);
array_init(notInValues);
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "model", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&record, this_ptr, "getoption", NULL, 0, _10$$7);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, values, singleField, PH_NOISY, "phalcon/validation/validator/uniqueness.zep", 178 TSRMLS_CC);
_11$$7 = ZEPHIR_IS_EMPTY(record);
if (!(_11$$7)) {
_11$$7 = Z_TYPE_P(record) != IS_OBJECT;
}
if (_11$$7) {
ZEPHIR_CALL_METHOD(&record, validation, "getentity", &_12, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(record)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Model of record must be set to property \"model\"", "phalcon/validation/validator/uniqueness.zep", 184);
return;
}
}
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_13$$7, this_ptr, "getoption", NULL, 0, _10$$7, singleField);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _13$$7);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
ZEPHIR_SINIT_NVAR(_15$$10);
ZVAL_LONG(&_15$$10, index);
ZEPHIR_INIT_LNVAR(_16$$10);
ZEPHIR_CONCAT_VSV(_16$$10, attribute, " = ?", &_15$$10);
zephir_array_update_multi(¶ms, &_16$$10 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &value TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
} else {
ZEPHIR_INIT_LNVAR(_17$$11);
ZEPHIR_CONCAT_VS(_17$$11, attribute, " IS NULL");
zephir_array_update_multi(¶ms, &_17$$11 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "except", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&except, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(except)) {
_18$$12 = Z_TYPE_P(except) == IS_ARRAY;
if (_18$$12) {
ZEPHIR_INIT_VAR(_19$$12);
zephir_array_keys(_19$$12, except TSRMLS_CC);
ZEPHIR_SINIT_VAR(_20$$12);
ZVAL_LONG(&_20$$12, 0);
ZEPHIR_SINIT_VAR(_21$$12);
ZVAL_LONG(&_21$$12, (zephir_fast_count_int(except TSRMLS_CC) - 1));
ZEPHIR_CALL_FUNCTION(&_22$$12, "range", NULL, 446, &_20$$12, &_21$$12);
zephir_check_call_status();
_18$$12 = !ZEPHIR_IS_IDENTICAL(_19$$12, _22$$12);
}
if (_18$$12) {
zephir_is_iterable(except, &_24$$13, &_23$$13, 0, 0, "phalcon/validation/validator/uniqueness.zep", 219);
for (
; zephir_hash_get_current_data_ex(_24$$13, (void**) &_25$$13, &_23$$13) == SUCCESS
; zephir_hash_move_forward_ex(_24$$13, &_23$$13)
) {
ZEPHIR_GET_HMKEY(singleField, _24$$13, _23$$13);
ZEPHIR_GET_HVALUE(fieldExcept, _25$$13);
ZEPHIR_INIT_NVAR(_27$$14);
ZVAL_STRING(_27$$14, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_26$$14, this_ptr, "getoption", NULL, 0, _27$$14, singleField);
zephir_check_temp_parameter(_27$$14);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _26$$14);
zephir_check_call_status();
if (Z_TYPE_P(fieldExcept) == IS_ARRAY) {
zephir_is_iterable(fieldExcept, &_29$$15, &_28$$15, 0, 0, "phalcon/validation/validator/uniqueness.zep", 212);
for (
; zephir_hash_get_current_data_ex(_29$$15, (void**) &_30$$15, &_28$$15) == SUCCESS
; zephir_hash_move_forward_ex(_29$$15, &_28$$15)
) {
ZEPHIR_GET_HVALUE(singleExcept, _30$$15);
ZEPHIR_SINIT_NVAR(_31$$16);
ZVAL_LONG(&_31$$16, index);
ZEPHIR_INIT_LNVAR(_32$$16);
ZEPHIR_CONCAT_SV(_32$$16, "?", &_31$$16);
zephir_array_append(¬InValues, _32$$16, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 208);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_33$$15);
zephir_fast_join_str(_33$$15, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_34$$15);
ZEPHIR_CONCAT_VSVS(_34$$15, attribute, " NOT IN (", _33$$15, ")");
zephir_array_append(&exceptConditions, _34$$15, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 212);
} else {
ZEPHIR_SINIT_NVAR(_35$$17);
ZVAL_LONG(&_35$$17, index);
ZEPHIR_INIT_LNVAR(_36$$17);
ZEPHIR_CONCAT_VSV(_36$$17, attribute, " <> ?", &_35$$17);
zephir_array_append(&exceptConditions, _36$$17, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 214);
zephir_array_update_multi(¶ms, &fieldExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
} else if (zephir_fast_count_int(field TSRMLS_CC) == 1) {
zephir_array_fetch_long(&_38$$18, field, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 220 TSRMLS_CC);
ZEPHIR_INIT_VAR(_39$$18);
ZVAL_STRING(_39$$18, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_37$$18, this_ptr, "getoption", NULL, 0, _39$$18, _38$$18);
zephir_check_temp_parameter(_39$$18);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _37$$18);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_41$$19, &_40$$19, 0, 0, "phalcon/validation/validator/uniqueness.zep", 227);
for (
; zephir_hash_get_current_data_ex(_41$$19, (void**) &_42$$19, &_40$$19) == SUCCESS
; zephir_hash_move_forward_ex(_41$$19, &_40$$19)
) {
ZEPHIR_GET_HVALUE(singleExcept, _42$$19);
ZEPHIR_SINIT_NVAR(_43$$20);
ZVAL_LONG(&_43$$20, index);
ZEPHIR_INIT_LNVAR(_44$$20);
ZEPHIR_CONCAT_SV(_44$$20, "?", &_43$$20);
zephir_array_append(¬InValues, _44$$20, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 223);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_VAR(_45$$19);
zephir_fast_join_str(_45$$19, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_VAR(_46$$19);
ZEPHIR_CONCAT_VSVS(_46$$19, attribute, " NOT IN (", _45$$19, ")");
zephir_array_append(&exceptConditions, _46$$19, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 227);
} else {
ZEPHIR_SINIT_VAR(_47$$21);
ZVAL_LONG(&_47$$21, index);
ZEPHIR_INIT_VAR(_48$$21);
ZEPHIR_CONCAT_VSV(_48$$21, attribute, " <> ?", &_47$$21);
zephir_array_update_multi(¶ms, &_48$$21 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
} else if (zephir_fast_count_int(field TSRMLS_CC) > 1) {
zephir_is_iterable(field, &_50$$22, &_49$$22, 0, 0, "phalcon/validation/validator/uniqueness.zep", 249);
for (
; zephir_hash_get_current_data_ex(_50$$22, (void**) &_51$$22, &_49$$22) == SUCCESS
; zephir_hash_move_forward_ex(_50$$22, &_49$$22)
) {
ZEPHIR_GET_HVALUE(singleField, _51$$22);
ZEPHIR_INIT_NVAR(_53$$23);
ZVAL_STRING(_53$$23, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_52$$23, this_ptr, "getoption", NULL, 0, _53$$23, singleField);
zephir_check_temp_parameter(_53$$23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _52$$23);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_55$$24, &_54$$24, 0, 0, "phalcon/validation/validator/uniqueness.zep", 242);
for (
; zephir_hash_get_current_data_ex(_55$$24, (void**) &_56$$24, &_54$$24) == SUCCESS
; zephir_hash_move_forward_ex(_55$$24, &_54$$24)
) {
ZEPHIR_GET_HVALUE(singleExcept, _56$$24);
ZEPHIR_SINIT_NVAR(_57$$25);
ZVAL_LONG(&_57$$25, index);
ZEPHIR_INIT_LNVAR(_58$$25);
ZEPHIR_CONCAT_SV(_58$$25, "?", &_57$$25);
zephir_array_append(¬InValues, _58$$25, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 238);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_59$$24);
zephir_fast_join_str(_59$$24, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_60$$24);
ZEPHIR_CONCAT_VSVS(_60$$24, attribute, " NOT IN (", _59$$24, ")");
zephir_array_append(&exceptConditions, _60$$24, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 242);
} else {
ZEPHIR_SINIT_NVAR(_61$$26);
ZVAL_LONG(&_61$$26, index);
ZEPHIR_INIT_LNVAR(_62$$26);
ZEPHIR_CONCAT_VSV(_62$$26, attribute, " <> ?", &_61$$26);
zephir_array_update_multi(¶ms, &_62$$26 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
}
}
ZEPHIR_CALL_METHOD(&_63, record, "getdirtystate", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_63, 0)) {
ZEPHIR_CALL_METHOD(&_64$$27, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_65$$27);
ZVAL_STRING(_65$$27, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, _64$$27, "getshared", NULL, 0, _65$$27);
zephir_check_temp_parameter(_65$$27);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_66$$27, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_66$$27, &_68$$27, &_67$$27, 0, 0, "phalcon/validation/validator/uniqueness.zep", 263);
for (
; zephir_hash_get_current_data_ex(_68$$27, (void**) &_69$$27, &_67$$27) == SUCCESS
; zephir_hash_move_forward_ex(_68$$27, &_67$$27)
) {
ZEPHIR_GET_HVALUE(primaryField, _69$$27);
ZEPHIR_CALL_METHOD(&_70$$28, this_ptr, "getcolumnnamereal", &_14, 0, record, primaryField);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_71$$28);
ZVAL_LONG(&_71$$28, index);
ZEPHIR_INIT_LNVAR(_72$$28);
ZEPHIR_CONCAT_VSV(_72$$28, _70$$28, " <> ?", &_71$$28);
zephir_array_update_multi(¶ms, &_72$$28 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
ZEPHIR_CALL_METHOD(&_73$$28, record, "readattribute", NULL, 0, primaryField);
zephir_check_call_status();
zephir_array_update_multi(¶ms, &_73$$28 TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(exceptConditions))) {
ZEPHIR_INIT_VAR(_74$$29);
zephir_fast_join_str(_74$$29, SL(" OR "), exceptConditions TSRMLS_CC);
ZEPHIR_INIT_VAR(_75$$29);
ZEPHIR_CONCAT_SVS(_75$$29, "(", _74$$29, ")");
zephir_array_update_multi(¶ms, &_75$$29 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
ZEPHIR_INIT_NVAR(_0);
zephir_array_fetch_string(&_76, params, SL("conditions"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 269 TSRMLS_CC);
zephir_fast_join_str(_0, SL(" AND "), _76 TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
_78 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_77, _78, "count", NULL, 0, params);
zephir_check_call_status();
RETURN_MM_BOOL(ZEPHIR_IS_LONG(_77, 0));
}
/**
* Initialize the metadata for certain table
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize) {
zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *key, *table, *schema, *strategy = NULL, *className = NULL, *metaData = NULL, *data = NULL, *modelMetadata = NULL, *modelColumnMap = NULL, *dependencyInjector = NULL, *keyName = NULL, *prefixKey = NULL, *_3, *_0$$8, *_1$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &model, &key, &table, &schema);
ZEPHIR_INIT_VAR(strategy);
ZVAL_NULL(strategy);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
ZEPHIR_OBS_VAR(metaData);
zephir_read_property_this(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(metaData, key))) {
ZEPHIR_INIT_VAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "meta-", key);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_metaData"), key, data TSRMLS_CC);
} else {
if ((zephir_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&modelMetadata, model, "metadata", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(modelMetadata) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0$$8);
object_init_ex(_0$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_1$$8);
ZEPHIR_CONCAT_SV(_1$$8, "Invalid meta-data for model ", className);
ZEPHIR_CALL_METHOD(NULL, _0$$8, "__construct", NULL, 9, _1$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$8, "phalcon/mvc/model/metadata.zep", 122 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&modelMetadata, strategy, "getmetadata", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_metaData"), key, modelMetadata TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelMetadata);
zephir_check_call_status();
}
}
}
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(keyName);
zephir_fast_strtolower(keyName, className);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (zephir_array_isset(_3, keyName)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_NVAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "map-", keyName);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, data TSRMLS_CC);
RETURN_MM_NULL();
}
if (Z_TYPE_P(strategy) != IS_OBJECT) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&modelColumnMap, strategy, "getcolumnmaps", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, modelColumnMap TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelColumnMap);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate) {
HashTable *_2$$5, *_22$$16;
HashPosition _1$$5, _21$$16;
zend_class_entry *_33;
zephir_fcall_cache_entry *_6 = NULL, *_12 = NULL, *_31 = NULL;
int ZEPHIR_LAST_CALL_STATUS, number = 0;
zval *record, *field = NULL, *dependencyInjector = NULL, *metaData = NULL, *message = NULL, *bindTypes = NULL, *bindDataTypes = NULL, *columnMap = NULL, *conditions = NULL, *bindParams = NULL, *composeField = NULL, *columnField = NULL, *bindType = NULL, *primaryField = NULL, *attributeField = NULL, *params = NULL, *className = NULL, *replacePairs = NULL, *_0 = NULL, *_19 = NULL, *_32 = NULL, **_3$$5, *_4$$8 = NULL, *_5$$8 = NULL, *_7$$10 = NULL, *_8$$10 = NULL, _9$$6 = zval_used_for_init, *_10$$6 = NULL, *_11$$6 = NULL, *_13$$13, *_14$$13, *_15$$15, *_16$$15, *_17$$11, *_18$$11 = NULL, *_20$$16 = NULL, **_23$$16, *_24$$20 = NULL, *_25$$20 = NULL, *_26$$22 = NULL, *_27$$22 = NULL, _28$$19 = zval_used_for_init, *_29$$19 = NULL, *_30$$19 = NULL, *_34$$24 = NULL, *_36$$24 = NULL, *_35$$25;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_CALL_METHOD(&dependencyInjector, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bindTypes);
array_init(bindTypes);
ZEPHIR_CALL_METHOD(&bindDataTypes, metaData, "getbindtypes", NULL, 0, record);
zephir_check_call_status();
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
number = 0;
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 127);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(composeField, _3$$5);
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, composeField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_4$$8);
object_init_ex(_4$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_5$$8);
ZEPHIR_CONCAT_SVS(_5$$8, "Column '", composeField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _4$$8, "__construct", &_6, 9, _5$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$8, "phalcon/mvc/model/validator/uniqueness.zep", 104 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, composeField);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7$$10);
object_init_ex(_7$$10, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8$$10);
ZEPHIR_CONCAT_SVS(_8$$10, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_6, 9, _8$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/validator/uniqueness.zep", 114 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_SINIT_NVAR(_9$$6);
ZVAL_LONG(&_9$$6, number);
ZEPHIR_INIT_LNVAR(_10$$6);
ZEPHIR_CONCAT_SVSV(_10$$6, "[", composeField, "] = ?", &_9$$6);
zephir_array_append(&conditions, _10$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 120);
ZEPHIR_CALL_METHOD(&_11$$6, record, "readattribute", &_12, 0, composeField);
zephir_check_call_status();
zephir_array_append(&bindParams, _11$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 121);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 122);
number++;
}
} else {
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, field, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_13$$13);
object_init_ex(_13$$13, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_14$$13);
ZEPHIR_CONCAT_SVS(_14$$13, "Column '", field, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _13$$13, "__construct", &_6, 9, _14$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_13$$13, "phalcon/mvc/model/validator/uniqueness.zep", 134 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, field);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_15$$15);
object_init_ex(_15$$15, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_16$$15);
ZEPHIR_CONCAT_SVS(_16$$15, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _15$$15, "__construct", &_6, 9, _16$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_15$$15, "phalcon/mvc/model/validator/uniqueness.zep", 144 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_17$$11);
ZEPHIR_CONCAT_SVS(_17$$11, "[", field, "] = ?0");
zephir_array_append(&conditions, _17$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 150);
ZEPHIR_CALL_METHOD(&_18$$11, record, "readattribute", NULL, 0, field);
zephir_check_call_status();
zephir_array_append(&bindParams, _18$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 151);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 152);
number++;
}
ZEPHIR_CALL_METHOD(&_19, record, "getoperationmade", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_19, 2)) {
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_CALL_METHOD(&_20$$16, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_20$$16, &_22$$16, &_21$$16, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 197);
for (
; zephir_hash_get_current_data_ex(_22$$16, (void**) &_23$$16, &_21$$16) == SUCCESS
; zephir_hash_move_forward_ex(_22$$16, &_21$$16)
) {
ZEPHIR_GET_HVALUE(primaryField, _23$$16);
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_24$$20);
object_init_ex(_24$$20, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_25$$20);
ZEPHIR_CONCAT_SVS(_25$$20, "Column '", primaryField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _24$$20, "__construct", &_6, 9, _25$$20);
zephir_check_call_status();
zephir_throw_exception_debug(_24$$20, "phalcon/mvc/model/validator/uniqueness.zep", 174 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(attributeField);
if (!(zephir_array_isset_fetch(&attributeField, columnMap, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_26$$22);
object_init_ex(_26$$22, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_27$$22);
ZEPHIR_CONCAT_SVS(_27$$22, "Column '", primaryField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _26$$22, "__construct", &_6, 9, _27$$22);
zephir_check_call_status();
zephir_throw_exception_debug(_26$$22, "phalcon/mvc/model/validator/uniqueness.zep", 182 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(attributeField, primaryField);
}
ZEPHIR_SINIT_NVAR(_28$$19);
ZVAL_LONG(&_28$$19, number);
ZEPHIR_INIT_LNVAR(_29$$19);
ZEPHIR_CONCAT_SVSV(_29$$19, "[", attributeField, "] <> ?", &_28$$19);
zephir_array_append(&conditions, _29$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 191);
ZEPHIR_CALL_METHOD(&_30$$19, record, "readattribute", &_31, 0, primaryField);
zephir_check_call_status();
zephir_array_append(&bindParams, _30$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 192);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 193);
number++;
}
}
ZEPHIR_INIT_VAR(params);
array_init(params);
zephir_array_update_string(¶ms, SL("di"), &dependencyInjector, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_join_str(_0, SL(" AND "), conditions TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bind"), &bindParams, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bindTypes"), &bindTypes, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
_33 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_32, _33, "count", NULL, 0, params);
zephir_check_call_status();
if (!ZEPHIR_IS_LONG(_32, 0)) {
ZEPHIR_INIT_VAR(_34$$24);
ZVAL_STRING(_34$$24, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_35$$25);
zephir_fast_join_str(_35$$25, SL(", "), field TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":fields"), &_35$$25, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of fields: :fields are already present in another record", 1);
}
} else {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &field, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field: ':field' is already present in another record", 1);
}
}
ZEPHIR_CALL_FUNCTION(&_36$$24, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_34$$24);
ZVAL_STRING(_34$$24, "Unique", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _36$$24, field, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Magic method __get
*/
PHP_METHOD(Phalcon_Di_Injectable, __get) {
zval *_4$$7;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *propertyName_param = NULL, *dependencyInjector = NULL, *service = NULL, *persistent = NULL, *_0, *_2 = NULL, *_3$$7 = NULL, *_5$$7 = NULL;
zval *propertyName = NULL, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &propertyName_param);
if (UNEXPECTED(Z_TYPE_P(propertyName_param) != IS_STRING && Z_TYPE_P(propertyName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'propertyName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(propertyName_param) == IS_STRING)) {
zephir_get_strval(propertyName, propertyName_param);
} else {
ZEPHIR_INIT_VAR(propertyName);
ZVAL_EMPTY_STRING(propertyName);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_1, 1);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services", "phalcon/di/injectable.zep", 127);
return;
}
}
ZEPHIR_CALL_METHOD(&_2, dependencyInjector, "has", NULL, 0, propertyName);
zephir_check_call_status();
if (zephir_is_true(_2)) {
ZEPHIR_CALL_METHOD(&service, dependencyInjector, "getshared", NULL, 0, propertyName);
zephir_check_call_status();
zephir_update_property_zval_zval(this_ptr, propertyName, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (ZEPHIR_IS_STRING(propertyName, "di")) {
zephir_update_property_this(this_ptr, SL("di"), dependencyInjector TSRMLS_CC);
RETURN_CCTOR(dependencyInjector);
}
if (ZEPHIR_IS_STRING(propertyName, "persistent")) {
ZEPHIR_INIT_VAR(_4$$7);
zephir_create_array(_4$$7, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_5$$7);
zephir_get_class(_5$$7, this_ptr, 0 TSRMLS_CC);
zephir_array_fast_append(_4$$7, _5$$7);
ZEPHIR_INIT_NVAR(_5$$7);
ZVAL_STRING(_5$$7, "sessionBag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$7, dependencyInjector, "get", NULL, 0, _5$$7, _4$$7);
zephir_check_temp_parameter(_5$$7);
zephir_check_call_status();
ZEPHIR_CPY_WRT(persistent, _3$$7);
zephir_update_property_this(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SV(_6, "Access to undefined property ", propertyName);
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", NULL, 2, _6);
zephir_check_call_status();
RETURN_MM_NULL();
}
/**
* Sets the expiration time for this cache item.
*
* @param int|\DateInterval time
* The period of time from the present after which the item MUST be considered
* expired. An integer parameter is understood to be the time in seconds until
* expiration. If null is passed explicitly, a default value MAY be used.
* If none is set, the value should be stored permanently or for as long as the
* implementation allows.
*
* @return \Xpl\Cache\Item
* The called object.
*/
PHP_METHOD(Xpl_Cache_Item, expiresAfter) {
zend_class_entry *_6$$7;
int ZEPHIR_LAST_CALL_STATUS;
zval *time, *_0$$3, *_1$$3, *_2$$3, *_3$$5, *_4$$5, *_5$$7 = NULL, *_7$$7, *_8$$7 = NULL, *_9$$7 = NULL, *_10$$7 = NULL, *_11$$8, *_12$$8 = NULL, _13$$8, *_14$$8 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &time);
if (Z_TYPE_P(time) == IS_NULL) {
ZEPHIR_INIT_VAR(_0$$3);
zephir_time(_0$$3);
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("defaultTtl"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2$$3);
zephir_add_function(_2$$3, _0$$3, _1$$3);
zephir_update_property_this(this_ptr, SL("expires"), _2$$3 TSRMLS_CC);
} else {
if (Z_TYPE_P(time) == IS_LONG) {
ZEPHIR_INIT_VAR(_3$$5);
zephir_time(_3$$5);
ZEPHIR_INIT_VAR(_4$$5);
zephir_add_function(_4$$5, _3$$5, time);
zephir_update_property_this(this_ptr, SL("expires"), _4$$5 TSRMLS_CC);
} else {
if (zephir_instance_of_ev(time, zephir_get_internal_ce(SS("dateinterval") TSRMLS_CC) TSRMLS_CC)) {
_6$$7 = zend_fetch_class(SL("DateTime"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
ZEPHIR_INIT_VAR(_7$$7);
zephir_time(_7$$7);
ZEPHIR_INIT_VAR(_8$$7);
ZVAL_STRING(_8$$7, "U", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_CE_STATIC(&_5$$7, _6$$7, "createfromformat", NULL, 0, _8$$7, _7$$7);
zephir_check_temp_parameter(_8$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_9$$7, _5$$7, "add", NULL, 0, time);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_8$$7);
ZVAL_STRING(_8$$7, "U", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_10$$7, _9$$7, "format", NULL, 0, _8$$7);
zephir_check_temp_parameter(_8$$7);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("expires"), _10$$7 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_11$$8);
object_init_ex(_11$$8, xpl_cache_invalidargumentexception_ce);
ZEPHIR_INIT_VAR(_12$$8);
if (Z_TYPE_P(time) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_12$$8);
zephir_get_class(_12$$8, time, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_12$$8);
zephir_gettype(_12$$8, time TSRMLS_CC);
}
ZEPHIR_SINIT_VAR(_13$$8);
ZVAL_STRING(&_13$$8, "Expiration date must be integer, DateInterval or null, given: \"%s\".", 0);
ZEPHIR_CALL_FUNCTION(&_14$$8, "sprintf", NULL, 41, &_13$$8, _12$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _11$$8, "__construct", NULL, 42, _14$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_11$$8, "xpl/cache/item.zep", 181 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
RETURN_THIS();
}
