/**
* Check if the current message in the iterator is valid
*/
PHP_METHOD(Phalcon_Validation_Message_Group, valid) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_position"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, _1));
}
/**
* Check if the current element in the iterator is valid
*/
PHP_METHOD(Phalcon_Forms_Form, valid) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_elementsIndexed"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_position"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, _1));
}
/**
* Check if the current annotation in the iterator is valid
*/
PHP_METHOD(Phalcon_Annotations_Collection, valid) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_annotations"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_position"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, _1));
}
/**
* Removes an access from a resource
*
* @param array|string accessList
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, dropResourceAccess) {
HashTable *_1$$3;
HashPosition _0$$3;
zval *resourceName_param = NULL, *accessList, *accessName = NULL, *accessKey = NULL, **_2$$3, *_3$$4, *_4$$5, *_5$$7, *_6$$8;
zval *resourceName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &resourceName_param, &accessList);
zephir_get_strval(resourceName, resourceName_param);
if (Z_TYPE_P(accessList) == IS_ARRAY) {
zephir_is_iterable(accessList, &_1$$3, &_0$$3, 0, 0, "phalcon/acl/adapter/memory.zep", 390);
for (
; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zephir_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HVALUE(accessName, _2$$3);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSV(accessKey, resourceName, "!", accessName);
_3$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_accessList"), PH_NOISY_CC);
if (zephir_array_isset(_3$$4, accessKey)) {
_4$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_accessList"), PH_NOISY_CC);
zephir_array_unset(&_4$$5, accessKey, PH_SEPARATE);
}
}
} else {
if (Z_TYPE_P(accessList) == IS_STRING) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSV(accessKey, resourceName, "!", accessName);
_5$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_accessList"), PH_NOISY_CC);
if (zephir_array_isset(_5$$7, accessKey)) {
_6$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_accessList"), PH_NOISY_CC);
zephir_array_unset(&_6$$8, accessKey, PH_SEPARATE);
}
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_IssetTest, testIssetArray1) {
zval *a, *b;
zephir_fetch_params(0, 2, 0, &a, &b);
RETURN_BOOL(zephir_array_isset(a, b));
}
/**
* The column map is used in the case to get real column name
*/
PHP_METHOD(Phalcon_Validation_Validator_Uniqueness, getColumnNameReal) {
zend_bool _0, _7;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *record, *field_param = NULL, *_1, *_6, *_8, *_2$$3 = NULL, *_3$$3 = NULL, *_4$$3, *_5$$3 = NULL, *_9$$4, *_10$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &record, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
_0 = ZEPHIR_GLOBAL(orm).column_renaming;
if (_0) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("columnMap"), PH_NOISY_CC);
_0 = !zephir_is_true(_1);
}
if (_0) {
ZEPHIR_CALL_METHOD(&_2$$3, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4$$3);
ZVAL_STRING(_4$$3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$3, _2$$3, "getshared", NULL, 0, _4$$3);
zephir_check_temp_parameter(_4$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_5$$3, _3$$3, "getcolumnmap", NULL, 0, record);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("columnMap"), _5$$3 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(_6);
zephir_read_property_this(&_6, this_ptr, SL("columnMap"), PH_NOISY_CC);
_7 = Z_TYPE_P(_6) == IS_ARRAY;
if (_7) {
_8 = zephir_fetch_nproperty_this(this_ptr, SL("columnMap"), PH_NOISY_CC);
_7 = zephir_array_isset(_8, field);
}
if (_7) {
_9$$4 = zephir_fetch_nproperty_this(this_ptr, SL("columnMap"), PH_NOISY_CC);
zephir_array_fetch(&_10$$4, _9$$4, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 287 TSRMLS_CC);
RETURN_CTOR(_10$$4);
}
RETURN_CTOR(field);
}
/**
* 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();
}
/**
* Returns an argument in a specific position
*
* @param int|string position
* @return boolean
*/
PHP_METHOD(Phalcon_Annotations_Annotation, hasArgument) {
zval *position, *_0;
zephir_fetch_params(0, 1, 0, &position);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_arguments"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, position));
}
/**
* Check if an option exists
*/
PHP_METHOD(Phalcon_Cli_Dispatcher, hasOption) {
zval *option, *_0;
zephir_fetch_params(0, 1, 0, &option);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, option));
}
PHP_METHOD(Test_Unsettest, has) {
zval *key, *_0;
zephir_fetch_params(0, 1, 0, &key);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("property"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, key));
}
/**
* Check if route exists in collection
*
* @see ArrayAccess
* @param mixed offset
* @return bool
*/
PHP_METHOD(Prr_RouteCollection, offsetExists) {
zval *offset, *_0;
zephir_fetch_params(0, 1, 0, &offset);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, offset));
}
/**
* Check whether a session variable is set in an application context
*
*<code>
* var_dump($session->has('auth'));
*</code>
*/
PHP_METHOD(Phalcon_Session_Adapter, has) {
zval *index_param = NULL, *_SESSION, *uniqueId = NULL, *_0$$3;
zval *index = NULL;
ZEPHIR_MM_GROW();
zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC);
zephir_fetch_params(1, 1, 0, &index_param);
zephir_get_strval(index, index_param);
uniqueId = zephir_fetch_nproperty_this(this_ptr, SL("_uniqueId"), PH_NOISY_CC);
if (!(ZEPHIR_IS_EMPTY(uniqueId))) {
ZEPHIR_INIT_VAR(_0$$3);
ZEPHIR_CONCAT_VSV(_0$$3, uniqueId, "#", index);
RETURN_MM_BOOL(zephir_array_isset(_SESSION, _0$$3));
}
RETURN_MM_BOOL(zephir_array_isset(_SESSION, index));
}
/**
* Check if a param exists
*
* @param mixed param
* @return boolean
*/
PHP_METHOD(Phalcon_Dispatcher, hasParam) {
zval *param, *_0;
zephir_fetch_params(0, 1, 0, ¶m);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
RETURN_BOOL(zephir_array_isset(_0, param));
}
/**
* Remove an object from the container
*
* @param string offset
* @throws Exception
* @return DiInterface
*/
PHP_METHOD(Pdm_Di_Container, remove) {
zval *offset_param = NULL, *_0, *_1, *_2;
zval *offset = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &offset_param);
if (unlikely(Z_TYPE_P(offset_param) != IS_STRING && Z_TYPE_P(offset_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'offset' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(offset_param) == IS_STRING)) {
offset = offset_param;
} else {
ZEPHIR_INIT_VAR(offset);
ZVAL_EMPTY_STRING(offset);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("container"), PH_NOISY_CC);
if (zephir_array_isset(_0, offset)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("container"), PH_NOISY_CC);
zephir_array_unset(&_1, offset, PH_SEPARATE);
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("sharedContainer"), PH_NOISY_CC);
if (zephir_array_isset(_1, offset)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("sharedContainer"), PH_NOISY_CC);
zephir_array_unset(&_2, offset, PH_SEPARATE);
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("paramContainer"), PH_NOISY_CC);
if (zephir_array_isset(_1, offset)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("paramContainer"), PH_NOISY_CC);
zephir_array_unset(&_2, offset, PH_SEPARATE);
}
RETURN_THIS();
}
/**
* Support isset() overloading on PHP 5.1
*
* @param string $name
* @return boolean
*/
PHP_METHOD(Yaf_Session, __isset) {
zval *name_param = NULL, *_0, *_1, *_SESSION;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(name, name_param);
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("session"), PH_NOISY_CC);
if (zephir_array_isset(_1, name)) {
ZVAL_BOOL(_0, 1);
} else {
zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC);
ZVAL_BOOL(_0, zephir_array_isset(_SESSION, name));
}
RETURN_CCTOR(_0);
}
PHP_METHOD(Test_IssetTest, testIssetArray3) {
zval *b = NULL;
zval *a, *b_param = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &a, &b_param);
zephir_get_strval(b, b_param);
RETURN_MM_BOOL(zephir_array_isset(a, b));
}
/**
* Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
*
* Example:
* <code>
* $acl->addRole(
* new Phalcon\Acl\Role("administrator"),
* "consultant"
* );
*
* $acl->addRole("administrator", "consultant");
* </code>
*
* @param array|string accessInherits
* @param RoleInterface|string role
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addRole) {
zend_bool _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *role, *accessInherits = NULL, *roleName = NULL, *roleObject = NULL, *_1, *_2, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &role, &accessInherits);
if (!accessInherits) {
accessInherits = ZEPHIR_GLOBAL(global_null);
}
_0 = Z_TYPE_P(role) == IS_OBJECT;
if (_0) {
_0 = zephir_instance_of_ev(role, phalcon_acl_roleinterface_ce TSRMLS_CC);
}
if (_0) {
ZEPHIR_CALL_METHOD(&roleName, role, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(roleObject, role);
} else if (Z_TYPE_P(role) == IS_STRING) {
ZEPHIR_CPY_WRT(roleName, role);
ZEPHIR_INIT_NVAR(roleObject);
object_init_ex(roleObject, phalcon_acl_role_ce);
ZEPHIR_CALL_METHOD(NULL, roleObject, "__construct", NULL, 82, role);
zephir_check_call_status();
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Role must be either an string or implement RoleInterface", "phalcon/acl/adapter/memory.zep", 201);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (zephir_array_isset(_1, roleName)) {
RETURN_MM_BOOL(0);
}
zephir_update_property_array_append(this_ptr, SL("_roles"), roleObject TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("_rolesNames"), roleName, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_VS(_3, roleName, "!*!*");
zephir_update_property_array(this_ptr, SL("_access"), _3, _2 TSRMLS_CC);
if (Z_TYPE_P(accessInherits) != IS_NULL) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addinherit", NULL, 0, roleName, accessInherits);
zephir_check_call_status();
RETURN_MM();
}
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,
* [
* "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();
}
/**
* 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);
}
/**
* Checks if an index exists
*
*<code>
* var_dump(
* isset($message["database"])
* );
*</code>
*
* @param int index
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Message_Group, offsetExists) {
zval *index_param = NULL, *_0;
zval *index = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &index_param);
zephir_get_strval(index, index_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_0, index));
}
/**
* Checks if a form is registered in the forms manager
*/
PHP_METHOD(Phalcon_Forms_Manager, has) {
zval *name_param = NULL, *_0;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(name, name_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_forms"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_0, name));
}
/**
* Whether the given item exists in the cache.
*
* @param string key Item key.
* @return boolean True if a cached value exists, otherwise false.
*/
PHP_METHOD(Xpl_Cache_Driver_MemoryDriver, exists) {
zval *key_param = NULL, *_0;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &key_param);
zephir_get_strval(key, key_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_0, key));
}
/**
* Check if a model has certain attribute
*
*<code>
* var_dump(
* $metaData->hasAttribute(
* new Robots(),
* "name"
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, hasAttribute) {
int ZEPHIR_LAST_CALL_STATUS;
zval *attribute = NULL;
zval *model, *attribute_param = NULL, *columnMap = NULL, *_0$$4 = NULL, *_1$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &attribute_param);
zephir_get_strval(attribute, attribute_param);
ZEPHIR_CALL_METHOD(&columnMap, this_ptr, "getreversecolumnmap", NULL, 0, model);
zephir_check_call_status();
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
RETURN_MM_BOOL(zephir_array_isset(columnMap, attribute));
} else {
ZEPHIR_CALL_METHOD(&_0$$4, this_ptr, "readmetadata", NULL, 14, model);
zephir_check_call_status();
zephir_array_fetch_long(&_1$$4, _0$$4, 4, PH_READONLY, "phalcon/mvc/model/metadata.zep", 751 TSRMLS_CC);
RETURN_MM_BOOL(zephir_array_isset(_1$$4, attribute));
}
}
/**
* Returns whether an event has been completed.
*
* @param string eventId Event ID.
* @return boolean True if event has completed, otherwise false.
*/
PHP_METHOD(Xpl_Event_Manager, did) {
zval *eventId_param = NULL, *_0;
zval *eventId = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &eventId_param);
zephir_get_strval(eventId, eventId_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("completed"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_0, eventId));
}
/**
* Check whether resource exist in the resources list
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, isResource) {
zval *resourceName_param = NULL, *_0;
zval *resourceName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &resourceName_param);
zephir_get_strval(resourceName, resourceName_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
RETURN_MM_BOOL(zephir_array_isset(_0, resourceName));
}
PHP_METHOD(Lynx_ORM_ModelsManager, get) {
int ZEPHIR_LAST_CALL_STATUS;
zval *classname_param = NULL, *_0, *cacheDriver = NULL, *_1, *_2 = NULL, *_3, *_4, *_5;
zval *classname = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &classname_param);
if (unlikely(Z_TYPE_P(classname_param) != IS_STRING && Z_TYPE_P(classname_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'classname' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(classname_param) == IS_STRING)) {
zephir_get_strval(classname, classname_param);
} else {
ZEPHIR_INIT_VAR(classname);
ZVAL_EMPTY_STRING(classname);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("cacheLoaded"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("em"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "getconfiguration", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&cacheDriver, _2, "getcachedriver", NULL);
zephir_check_call_status();
if (zephir_is_true(cacheDriver)) {
}
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("cachedModels"), PH_NOISY_CC);
if (zephir_array_isset(_1, classname)) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("cachedModels"), PH_NOISY_CC);
zephir_array_fetch(&_4, _3, classname, PH_NOISY | PH_READONLY, "lynx/ORM/ModelsManager.zep", 42 TSRMLS_CC);
RETURN_CTOR(_4);
}
ZEPHIR_INIT_VAR(_5);
object_init_ex(_5, lynx_orm_modelmetadata_ce);
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, classname);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("cachedModels"), classname, _5 TSRMLS_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("cachedModels"), PH_NOISY_CC);
zephir_array_fetch(&_4, _1, classname, PH_NOISY | PH_READONLY, "lynx/ORM/ModelsManager.zep", 46 TSRMLS_CC);
RETURN_CTOR(_4);
}
/**
* Removes a message from the list
*
*<code>
* unset($message["database"]);
*</code>
*
* @param string index
*/
PHP_METHOD(Phalcon_Validation_Message_Group, offsetUnset) {
zval *index, *_0, *_1$$3;
zephir_fetch_params(0, 1, 0, &index);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
if (zephir_array_isset(_0, index)) {
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
zephir_array_unset(&_1$$3, index, PH_SEPARATE);
}
RETURN_BOOL(0);
}
/**
* Removes a property from the internal bag
*
*<code>
* $user->remove("name");
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, remove) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, _0, data, _1$$4, _2$$4;
zval property;
zval *this_ptr = getThis();
ZVAL_UNDEF(&property);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&data);
ZVAL_UNDEF(&_1$$4);
ZVAL_UNDEF(&_2$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(&property, property_param);
} else {
ZEPHIR_INIT_VAR(&property);
ZVAL_EMPTY_STRING(&property);
}
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(&data);
zephir_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (zephir_array_isset(&data, &property)) {
zephir_array_unset(&data, &property, PH_SEPARATE);
zephir_read_property(&_1$$4, this_ptr, SL("_session"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_2$$4, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &_1$$4, "set", NULL, 0, &_2$$4, &data);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("_data"), &data);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
/**
* Attempts to register a service in the services container
* Only is successful if a service hasn't been registered previously
* with the same name
*/
PHP_METHOD(Phalcon_Di, attempt) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool shared;
zval *name_param = NULL, *definition, *shared_param = NULL, *service = NULL, *_0, *_1$$3;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &name_param, &definition, &shared_param);
if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
if (!shared_param) {
shared = 0;
} else {
shared = zephir_get_boolval(shared_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_services"), PH_NOISY_CC);
if (!(zephir_array_isset(_0, name))) {
ZEPHIR_INIT_VAR(service);
object_init_ex(service, phalcon_di_service_ce);
ZEPHIR_INIT_VAR(_1$$3);
if (shared) {
ZVAL_BOOL(_1$$3, 1);
} else {
ZVAL_BOOL(_1$$3, 0);
}
ZEPHIR_CALL_METHOD(NULL, service, "__construct", NULL, 67, name, definition, _1$$3);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_services"), name, service TSRMLS_CC);
RETURN_CCTOR(service);
}
RETURN_MM_BOOL(0);
}
/**
* @param \Ouchbase\Entity entity
* @param string|null cas
* @throws \Ouchbase\Exception\EntityLogicException
* @return this
*/
PHP_METHOD(Ouchbase_UnitOfWork, persist) {
zval *_5;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
zval *entity, *cas = NULL, *_0, *_1 = NULL, *_3, *_4, *_6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &entity, &cas);
if (!cas) {
cas = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("deleted"), PH_NOISY_CC);
ZEPHIR_CALL_CE_STATIC(&_1, ouchbase__etc_ce, "getentityhash", &_2, entity);
zephir_check_call_status();
if (zephir_array_isset(_0, _1)) {
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, ouchbase_exception_entitylogicexception_ce);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "was marked as deleted", 0);
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, entity, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_throw_exception_debug(_3, "ouchbase/UnitOfWork.zep", 49 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_5);
array_init_size(_5, 3);
zephir_array_fast_append(_5, entity);
zephir_array_fast_append(_5, cas);
ZEPHIR_CALL_CE_STATIC(&_6, ouchbase__etc_ce, "getentityhash", &_2, entity);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("persisted"), _6, _5 TSRMLS_CC);
RETURN_THIS();
}
