自学教程：C++ zephir_array_isset函数代码示例

/** * 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, &param);	_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);}

/** * 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 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();}