예제 #1
0
PHP_METHOD(Test_BuiltIn_StringMethods, getParsedJson) {

	zend_bool assoc;
	zval *str_param = NULL, *assoc_param = NULL, _0, _1;
	zval str;
		zval this_zv;
	zval *this_ptr = getThis();
	if (EXPECTED(this_ptr)) {
		ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
		this_ptr = &this_zv;
	} else this_ptr = NULL;
	
	ZVAL_UNDEF(&str);
	ZVAL_UNDEF(&_0);
	ZVAL_UNDEF(&_1);

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 1, &str_param, &assoc_param);

	zephir_get_strval(&str, str_param);
	if (!assoc_param) {
		assoc = 1;
	} else {
		assoc = zephir_get_boolval(assoc_param);
	}


	ZEPHIR_INIT_VAR(&_0);
	ZVAL_BOOL(&_1, (assoc ? 1 : 0));
	zephir_json_decode(&_0, &str, zephir_get_intval(&str) );
	RETURN_CCTOR(_0);

}
예제 #2
0
/**
 * Execute parsing
 *
 * @param string input
 * @return mixed
 */
PHP_METHOD(Phal_Format_Reader_AbstractJsonReader, execute) {

	int ZEPHIR_LAST_CALL_STATUS;
	zval *input_param = NULL, *data;
	zval *input = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &input_param);

	if (unlikely(Z_TYPE_P(input_param) != IS_STRING && Z_TYPE_P(input_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'input' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}

	if (unlikely(Z_TYPE_P(input_param) == IS_STRING)) {
		input = input_param;
	} else {
		ZEPHIR_INIT_VAR(input);
		ZVAL_EMPTY_STRING(input);
	}


	ZEPHIR_INIT_VAR(data);
	zephir_json_decode(data, &(data), input, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
	ZEPHIR_RETURN_CALL_METHOD(this_ptr, "arraytoresource", NULL, data);
	zephir_check_call_status();
	RETURN_MM();

}
예제 #3
0
/**
 * Phalcon\Config\Adapter\Json constructor
 */
PHP_METHOD(Phalcon_Config_Adapter_Json, __construct) {

	int ZEPHIR_LAST_CALL_STATUS;
	zephir_fcall_cache_entry *_0 = NULL;
	zval *filePath_param = NULL, *_1, *_2;
	zval *filePath = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &filePath_param);

	if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) {
		zephir_get_strval(filePath, filePath_param);
	} else {
		ZEPHIR_INIT_VAR(filePath);
		ZVAL_EMPTY_STRING(filePath);
	}


	ZEPHIR_INIT_VAR(_1);
	ZEPHIR_INIT_VAR(_2);
	zephir_file_get_contents(_2, filePath TSRMLS_CC);
	zephir_json_decode(_1, &(_1), _2, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
	ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_json_ce, this_ptr, "__construct", &_0, 19, _1);
	zephir_check_call_status();
	ZEPHIR_MM_RESTORE();

}
예제 #4
0
파일: json.zep.c 프로젝트: wells5609/xpl
/**
 * Returns whether the given variable is a valid JSON string.
 *
 * @param string
 * @return boolean
 */
PHP_METHOD(Xpl_Json, validate) {

	zend_bool _0;
	int ZEPHIR_LAST_CALL_STATUS;
	zval *str_param = NULL, *_1, *_2 = NULL;
	zval *str = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &str_param);

	zephir_get_strval(str, str_param);


	if (ZEPHIR_IS_EMPTY(str)) {
		RETURN_MM_BOOL(0);
	}
	_0 = ZEPHIR_IS_STRING_IDENTICAL(str, "{}");
	if (!(_0)) {
		_0 = ZEPHIR_IS_STRING_IDENTICAL(str, "[]");
	}
	if (_0) {
		RETURN_MM_BOOL(1);
	}
	ZEPHIR_INIT_VAR(_1);
	zephir_json_decode(_1, &(_1), str, 0  TSRMLS_CC);
	ZEPHIR_CALL_FUNCTION(&_2, "json_last_error", NULL, 112);
	zephir_check_call_status();
	RETURN_MM_BOOL(ZEPHIR_IS_LONG_IDENTICAL(_2, 0));

}
예제 #5
0
파일: json.zep.c 프로젝트: duythien/zephir
PHP_METHOD(Test_Json, testDecodeObject) {

	zval *obj;

	ZEPHIR_MM_GROW();
	ZEPHIR_INIT_VAR(obj);
	ZVAL_STRING(obj, "{\"a\":\"hello\",\"b\":\"world\",\"c\":128}", 1);

	zephir_json_decode(return_value, &(return_value), obj, 0  TSRMLS_CC);
	RETURN_MM();

}
예제 #6
0
파일: json.zep.c 프로젝트: duythien/zephir
PHP_METHOD(Test_Json, testDecodeArray) {

	zval *arr;

	ZEPHIR_MM_GROW();

	ZEPHIR_INIT_VAR(arr);
	ZVAL_STRING(arr, "[1,2,3]", 1);
	zephir_json_decode(return_value, &(return_value), arr, 0  TSRMLS_CC);
	RETURN_MM();

}
예제 #7
0
파일: json.zep.c 프로젝트: wells5609/xpl
/**
 * Decodes a JSON-encoded string into an object or array
 *
 * @param string $json A well-formed JSON string.
 * @param boolean $assoc [Optional] Whether to decode to an associative array. Default false.
 * @param int $depth [Optional] Depth to decode to. Default 512
 * @param int $flags [Optional] Bitwise flags for use in json_decode(). Default is 0
 * @return object|array|null JSON data decoded to object(s) or array(s).
 */
PHP_METHOD(Xpl_Json, decode) {

	int depth, flags;
	zend_bool assoc;
	zval *json_param = NULL, *assoc_param = NULL, *depth_param = NULL, *flags_param = NULL, _0, _1, _2;
	zval *json = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 3, &json_param, &assoc_param, &depth_param, &flags_param);

	if (unlikely(Z_TYPE_P(json_param) != IS_STRING && Z_TYPE_P(json_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'json' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(json_param) == IS_STRING)) {
		zephir_get_strval(json, json_param);
	} else {
		ZEPHIR_INIT_VAR(json);
		ZVAL_EMPTY_STRING(json);
	}
	if (!assoc_param) {
		assoc = 0;
	} else {
		assoc = zephir_get_boolval(assoc_param);
	}
	if (!depth_param) {
		depth = 512;
	} else {
		depth = zephir_get_intval(depth_param);
	}
	if (!flags_param) {
		flags = 0;
	} else {
		flags = zephir_get_intval(flags_param);
	}


	if (ZEPHIR_IS_EMPTY(json)) {
		RETURN_MM_NULL();
	}
	ZEPHIR_SINIT_VAR(_0);
	ZVAL_BOOL(&_0, (assoc ? 1 : 0));
	ZEPHIR_SINIT_VAR(_1);
	ZVAL_LONG(&_1, depth);
	ZEPHIR_SINIT_VAR(_2);
	ZVAL_LONG(&_2, flags);
	zephir_json_decode(return_value, &(return_value), json, zephir_get_intval(&_0)  TSRMLS_CC);
	RETURN_MM();

}
예제 #8
0
PHP_METHOD(Yb_Task_TaskManagerAbstract, unserializeTask) {

	zval *task_param = NULL;
	zval *task = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &task_param);

	zephir_get_strval(task, task_param);


	zephir_json_decode(return_value, &(return_value), task, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
	RETURN_MM();

}
예제 #9
0
PHP_METHOD(Test_BuiltIn_StringMethods, getParsedJson) {

	zend_bool assoc;
	zval *str_param = NULL, *assoc_param = NULL, *_0;
	zval *str = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 1, &str_param, &assoc_param);

	zephir_get_strval(str, str_param);
	if (!assoc_param) {
		assoc = 1;
	} else {
		assoc = zephir_get_boolval(assoc_param);
	}


	ZEPHIR_INIT_VAR(_0);
	zephir_json_decode(_0, &(_0), str, zephir_get_intval(str)  TSRMLS_CC);
	RETURN_CCTOR(_0);

}
예제 #10
0
/**
 * Phalcon\Config\Adapter\Json constructor
 */
PHP_METHOD(Phalcon_Config_Adapter_Json, __construct) {

	zend_long ZEPHIR_LAST_CALL_STATUS;
	zephir_fcall_cache_entry *_0 = NULL;
	zval *filePath_param = NULL, __$true, _1, _2;
	zval filePath;
	zval *this_ptr = getThis();

	ZVAL_UNDEF(&filePath);
	ZVAL_BOOL(&__$true, 1);
	ZVAL_UNDEF(&_1);
	ZVAL_UNDEF(&_2);

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &filePath_param);

	if (UNEXPECTED(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be of the type string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (EXPECTED(Z_TYPE_P(filePath_param) == IS_STRING)) {
		zephir_get_strval(&filePath, filePath_param);
	} else {
		ZEPHIR_INIT_VAR(&filePath);
		ZVAL_EMPTY_STRING(&filePath);
	}


	ZEPHIR_INIT_VAR(&_1);
	ZEPHIR_INIT_VAR(&_2);
	zephir_file_get_contents(&_2, &filePath TSRMLS_CC);
	zephir_json_decode(&_1, &_2, zephir_get_intval(&__$true) );
	ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_json_ce, getThis(), "__construct", &_0, 0, &_1);
	zephir_check_call_status();
	ZEPHIR_MM_RESTORE();

}
예제 #11
0
파일: json.zep.c 프로젝트: wells5609/xpl
/**
 * Unserializes a value from a serialized string.
 *
 * @param string serializedData
 *
 * @return mixed
 */
PHP_METHOD(Xpl_Serializer_Json, unserialize) {

	zval *serializedData_param = NULL;
	zval *serializedData = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &serializedData_param);

	if (unlikely(Z_TYPE_P(serializedData_param) != IS_STRING && Z_TYPE_P(serializedData_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'serializedData' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(serializedData_param) == IS_STRING)) {
		zephir_get_strval(serializedData, serializedData_param);
	} else {
		ZEPHIR_INIT_VAR(serializedData);
		ZVAL_EMPTY_STRING(serializedData);
	}


	zephir_json_decode(return_value, &(return_value), serializedData, 0  TSRMLS_CC);
	RETURN_MM();

}
예제 #12
0
/**
 * @return mixed
 */
PHP_METHOD(Lynx_Annotation_RegexDocParser, parseValue) {

	int ZEPHIR_LAST_CALL_STATUS;
	zephir_nts_static zephir_fcall_cache_entry *_14 = NULL;
	HashTable *_11;
	HashPosition _10;
	zend_bool _3, _15, _20;
	zval *value, *val = NULL, *vals, *v = NULL, _0, _1, *_2, _4, *_5, _6 = zval_used_for_init, _7 = zval_used_for_init, *_8 = NULL, _9 = zval_used_for_init, **_12, *_13 = NULL, *_16, _17, _18, *_19, _21, *_22, _23, _24, *_25 = NULL, *_26;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 0, &value);



	ZEPHIR_INIT_VAR(val);
	zephir_fast_trim(val, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
	ZEPHIR_SINIT_VAR(_0);
	ZVAL_LONG(&_0, 0);
	ZEPHIR_SINIT_VAR(_1);
	ZVAL_LONG(&_1, 1);
	ZEPHIR_INIT_VAR(_2);
	zephir_substr(_2, val, 0 , 1 , 0);
	_3 = ZEPHIR_IS_STRING(_2, "[");
	if (_3) {
		ZEPHIR_SINIT_VAR(_4);
		ZVAL_LONG(&_4, -1);
		ZEPHIR_INIT_VAR(_5);
		zephir_substr(_5, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
		_3 = ZEPHIR_IS_STRING(_5, "]");
	}
	if (_3) {
		ZEPHIR_INIT_VAR(vals);
		ZEPHIR_SINIT_VAR(_6);
		ZVAL_LONG(&_6, 1);
		ZEPHIR_SINIT_VAR(_7);
		ZVAL_LONG(&_7, -1);
		ZEPHIR_INIT_VAR(_8);
		zephir_substr(_8, val, 1 , -1 , 0);
		ZEPHIR_SINIT_VAR(_9);
		ZVAL_LONG(&_9, ',');
		zephir_fast_explode(vals, &_9, _8, LONG_MAX TSRMLS_CC);
		ZEPHIR_INIT_NVAR(val);
		array_init(val);
		zephir_is_iterable(vals, &_11, &_10, 0, 0, "lynx/Annotation/RegexDocParser.zep", 89);
		for (
		  ; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
		  ; zephir_hash_move_forward_ex(_11, &_10)
		) {
			ZEPHIR_GET_HVALUE(v, _12);
			ZEPHIR_CALL_SELF(&_13, "parsevalue", &_14, v);
			zephir_check_call_status();
			zephir_array_append(&val, _13, PH_SEPARATE, "lynx/Annotation/RegexDocParser.zep", 86);
		}
		RETURN_CCTOR(val);
	} else {
		ZEPHIR_SINIT_NVAR(_6);
		ZVAL_LONG(&_6, 0);
		ZEPHIR_SINIT_NVAR(_7);
		ZVAL_LONG(&_7, 1);
		ZEPHIR_INIT_NVAR(_8);
		zephir_substr(_8, val, 0 , 1 , 0);
		_15 = ZEPHIR_IS_STRING(_8, "{");
		if (_15) {
			ZEPHIR_SINIT_NVAR(_9);
			ZVAL_LONG(&_9, -1);
			ZEPHIR_INIT_VAR(_16);
			zephir_substr(_16, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
			_15 = ZEPHIR_IS_STRING(_16, "}");
		}
		if (_15) {
			zephir_json_decode(return_value, &(return_value), val, 0  TSRMLS_CC);
			RETURN_MM();
		} else {
			ZEPHIR_SINIT_VAR(_17);
			ZVAL_LONG(&_17, 0);
			ZEPHIR_SINIT_VAR(_18);
			ZVAL_LONG(&_18, 1);
			ZEPHIR_INIT_VAR(_19);
			zephir_substr(_19, val, 0 , 1 , 0);
			_20 = ZEPHIR_IS_STRING(_19, "\"");
			if (_20) {
				ZEPHIR_SINIT_VAR(_21);
				ZVAL_LONG(&_21, -1);
				ZEPHIR_INIT_VAR(_22);
				zephir_substr(_22, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
				_20 = ZEPHIR_IS_STRING(_22, "\"");
			}
			if (_20) {
				ZEPHIR_SINIT_VAR(_23);
				ZVAL_LONG(&_23, 1);
				ZEPHIR_SINIT_VAR(_24);
				ZVAL_LONG(&_24, -1);
				ZEPHIR_INIT_VAR(_25);
				zephir_substr(_25, val, 1 , -1 , 0);
				ZEPHIR_CPY_WRT(val, _25);
				ZEPHIR_RETURN_CALL_SELF("parsevalue", &_14, val);
				zephir_check_call_status();
				RETURN_MM();
			} else {
				ZEPHIR_INIT_NVAR(_25);
				zephir_fast_strtolower(_25, val);
				if (ZEPHIR_IS_STRING(_25, "true")) {
					RETURN_MM_BOOL(1);
				} else {
					ZEPHIR_INIT_VAR(_26);
					zephir_fast_strtolower(_26, val);
					if (ZEPHIR_IS_STRING(_26, "false")) {
						RETURN_MM_BOOL(0);
					} else {
						if (zephir_is_numeric(val)) {
							if (zephir_get_doubleval(val) == zephir_get_intval(val)) {
								RETURN_MM_LONG(zephir_get_intval(val));
							} else {
								RETURN_MM_DOUBLE(zephir_get_doubleval(val));
							}
						}
					}
				}
			}
		}
	}
	RETURN_CCTOR(val);

}
예제 #13
0
/**
 * @param array ids
 * @param bool concurrent Only for entities fetched in this query
 * @return \Ouchbase\Entity[]
 */
PHP_METHOD(Ouchbase_Repository, findAll) {

	zephir_fcall_cache_entry *_7 = NULL;
	HashTable *_3;
	HashPosition _2;
	int ZEPHIR_LAST_CALL_STATUS;
	zval *_0;
	zend_bool concurrent;
	zval *ids, *concurrent_param = NULL, *entity = NULL, *entities, *cas, *data, *dataWithCas = NULL, *id = NULL, *entityData = NULL, *_1 = NULL, **_4, *_5, *_6, *_8, *_9, *_10 = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 1, &ids, &concurrent_param);

	if (!concurrent_param) {
		concurrent = 0;
	} else {
		concurrent = zephir_get_boolval(concurrent_param);
	}


	ZEPHIR_INIT_VAR(entities);
	array_init(entities);
	ZEPHIR_INIT_VAR(_0);
	array_init_size(_0, 2);
	zephir_array_fast_append(_0, ids);
	ZEPHIR_INIT_VAR(_1);
	ZVAL_STRING(_1, "__getMultiWithCas", 0);
	ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _1, _0);
	zephir_check_temp_parameter(_1);
	zephir_check_call_status();
	ZEPHIR_OBS_VAR(data);
	zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC);
	ZEPHIR_OBS_VAR(cas);
	zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC);
	zephir_is_iterable(data, &_3, &_2, 0, 0);
	for (
	  ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
	  ; zephir_hash_move_forward_ex(_3, &_2)
	) {
		ZEPHIR_GET_HMKEY(id, _3, _2);
		ZEPHIR_GET_HVALUE(entityData, _4);
		_5 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
		_6 = zephir_fetch_nproperty_this(this_ptr, SL("className"), PH_NOISY_CC);
		ZEPHIR_CALL_METHOD(&entity, _5, "getentity", NULL, _6, id);
		zephir_check_call_status();
		if (zephir_is_true(entity)) {
			zephir_array_append(&entities, entity, PH_SEPARATE);
			continue;
		}
		if (!(Z_TYPE_P(entityData) == IS_ARRAY)) {
			ZEPHIR_INIT_NVAR(_1);
			zephir_json_decode(_1, &(_1), entityData, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
			ZEPHIR_CPY_WRT(entityData, _1);
		}
		ZEPHIR_CALL_METHOD(&entity, this_ptr, "toobject", &_7, entityData);
		zephir_check_call_status();
		_8 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
		ZEPHIR_CALL_METHOD(NULL, _8, "register", NULL, entity, entityData);
		zephir_check_call_status();
		_9 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC);
		ZEPHIR_INIT_LNVAR(_10);
		if (concurrent) {
			ZEPHIR_OBS_NVAR(_10);
			zephir_array_fetch(&_10, cas, id, PH_NOISY TSRMLS_CC);
		} else {
			ZEPHIR_INIT_NVAR(_10);
			ZVAL_NULL(_10);
		}
		ZEPHIR_CALL_METHOD(NULL, _9, "persist", NULL, entity, _10);
		zephir_check_call_status();
		zephir_array_append(&entities, entity, PH_SEPARATE);
	}
	RETURN_CCTOR(entities);

}
예제 #14
0
/**
 * @param \Ouchbase\Entity entity
 * @param bool concurrent If entity may have concurrent updates
 * @throws \Ouchbase\Exception\EntityLogicException
 * @return this
 */
PHP_METHOD(Ouchbase_Repository, refresh) {

	zephir_fcall_cache_entry *_12 = NULL, *_14 = NULL, *_15 = NULL;
	HashTable *_9;
	HashPosition _8;
	zval *_4;
	int ZEPHIR_LAST_CALL_STATUS;
	zend_bool concurrent;
	zval *entity = NULL, *concurrent_param = NULL, *_0, *_1 = NULL, *_2, *_3 = NULL, *cas, *data = NULL, *dataWithCas = NULL, *_5 = NULL, *refreshed = NULL, *_6, *property = NULL, *propertyReflection = NULL, *_7 = NULL, **_10, *_11 = NULL, *_13 = NULL, *_16;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 1, &entity, &concurrent_param);

	ZEPHIR_SEPARATE_PARAM(entity);
	if (!concurrent_param) {
		concurrent = 0;
	} else {
		concurrent = zephir_get_boolval(concurrent_param);
	}


	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("im"), PH_NOISY_CC);
	ZEPHIR_CALL_METHOD(&_1, _0, "contains", NULL, entity);
	zephir_check_call_status();
	if (!(zephir_is_true(_1))) {
		ZEPHIR_INIT_VAR(_2);
		object_init_ex(_2, ouchbase_exception_entitylogicexception_ce);
		ZEPHIR_INIT_VAR(_3);
		ZVAL_STRING(_3, "was not persisted", 0);
		ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, entity, _3);
		zephir_check_temp_parameter(_3);
		zephir_check_call_status();
		zephir_throw_exception_debug(_2, "ouchbase/Repository.zep", 97 TSRMLS_CC);
		ZEPHIR_MM_RESTORE();
		return;
	}
	if (zephir_instance_of_ev(entity, ouchbase_entityproxy_ce TSRMLS_CC)) {
		ZEPHIR_CALL_METHOD(&entity, entity, "_getobject",  NULL);
		zephir_check_call_status();
	}
	ZEPHIR_INIT_VAR(_4);
	array_init_size(_4, 2);
	ZEPHIR_CALL_METHOD(&_5, entity, "getid",  NULL);
	zephir_check_call_status();
	zephir_array_fast_append(_4, _5);
	ZEPHIR_INIT_NVAR(_3);
	ZVAL_STRING(_3, "__getWithCas", 0);
	ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _3, _4);
	zephir_check_temp_parameter(_3);
	zephir_check_call_status();
	ZEPHIR_OBS_VAR(data);
	zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC);
	ZEPHIR_OBS_VAR(cas);
	zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC);
	if (!(zephir_is_true(data))) {
		RETURN_THIS();
	}
	if (!(Z_TYPE_P(data) == IS_ARRAY)) {
		ZEPHIR_INIT_NVAR(_3);
		zephir_json_decode(_3, &(_3), data, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
		ZEPHIR_CPY_WRT(data, _3);
	}
	ZEPHIR_CALL_METHOD(&refreshed, this_ptr, "toobject", NULL, data);
	zephir_check_call_status();
	_6 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
	ZEPHIR_CALL_METHOD(NULL, _6, "updateoriginaldata", NULL, entity, data);
	zephir_check_call_status();
	ZEPHIR_CALL_METHOD(&_5, this_ptr, "getclassreflection",  NULL);
	zephir_check_call_status();
	ZEPHIR_CALL_METHOD(&_7, _5, "getproperties",  NULL);
	zephir_check_call_status();
	zephir_is_iterable(_7, &_9, &_8, 0, 0);
	for (
	  ; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
	  ; zephir_hash_move_forward_ex(_9, &_8)
	) {
		ZEPHIR_GET_HVALUE(property, _10);
		ZEPHIR_CALL_METHOD(&_11, property, "getname",  NULL);
		zephir_check_call_status();
		ZEPHIR_CALL_METHOD(&propertyReflection, this_ptr, "getpropertyreflection", &_12, _11);
		zephir_check_call_status();
		ZEPHIR_CALL_METHOD(&_13, propertyReflection, "getvalue", &_14, refreshed);
		zephir_check_call_status();
		ZEPHIR_CALL_METHOD(NULL, propertyReflection, "setvalue", &_15, entity, _13);
		zephir_check_call_status();
	}
	if (concurrent) {
		_16 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC);
		ZEPHIR_CALL_METHOD(NULL, _16, "persist", NULL, entity, cas);
		zephir_check_call_status();
	}
	RETURN_THIS();

}
예제 #15
0
/**
 * @param int|string id
 * @param bool concurrent
 * @return \Ouchbase\Entity|null
 */
PHP_METHOD(Ouchbase_Repository, find) {

	zval *_2;
	int ZEPHIR_LAST_CALL_STATUS;
	zend_bool concurrent;
	zval *id, *concurrent_param = NULL, *entity = NULL, *_0, *_1, *cas, *data = NULL, *dataWithCas = NULL, *_3, *_4, *_5, *_6 = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 1, 1, &id, &concurrent_param);

	if (!concurrent_param) {
		concurrent = 0;
	} else {
		concurrent = zephir_get_boolval(concurrent_param);
	}


	_0 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
	_1 = zephir_fetch_nproperty_this(this_ptr, SL("className"), PH_NOISY_CC);
	ZEPHIR_CALL_METHOD(&entity, _0, "getentity", NULL, _1, id);
	zephir_check_call_status();
	if (zephir_is_true(entity)) {
		RETURN_CCTOR(entity);
	}
	ZEPHIR_INIT_VAR(_2);
	array_init_size(_2, 2);
	zephir_array_fast_append(_2, id);
	ZEPHIR_INIT_VAR(_3);
	ZVAL_STRING(_3, "__getWithCas", 0);
	ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _3, _2);
	zephir_check_temp_parameter(_3);
	zephir_check_call_status();
	ZEPHIR_OBS_VAR(data);
	zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC);
	ZEPHIR_OBS_VAR(cas);
	zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC);
	if (!(zephir_is_true(data))) {
		RETURN_MM_NULL();
	}
	if (!(Z_TYPE_P(data) == IS_ARRAY)) {
		ZEPHIR_INIT_BNVAR(_3);
		zephir_json_decode(_3, &(_3), data, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
		ZEPHIR_CPY_WRT(data, _3);
	}
	ZEPHIR_CALL_METHOD(&entity, this_ptr, "toobject", NULL, data);
	zephir_check_call_status();
	_4 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC);
	ZEPHIR_CALL_METHOD(NULL, _4, "register", NULL, entity, data);
	zephir_check_call_status();
	_5 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC);
	ZEPHIR_INIT_VAR(_6);
	if (concurrent) {
		ZEPHIR_CPY_WRT(_6, cas);
	} else {
		ZEPHIR_INIT_BNVAR(_6);
		ZVAL_NULL(_6);
	}
	ZEPHIR_CALL_METHOD(NULL, _5, "persist", NULL, entity, _6);
	zephir_check_call_status();
	RETURN_CCTOR(entity);

}
예제 #16
0
PHP_METHOD(Transbybd_TransApi, translate) {

	zval *args = NULL;
	int ZEPHIR_LAST_CALL_STATUS;
	zval *query_param = NULL, *from_param = NULL, *to_param = NULL, *ret = NULL, *_0, _1, _2, *_3 = NULL, *_4, *_5;
	zval *query = NULL, *from = NULL, *to = NULL;

	ZEPHIR_MM_GROW();
	zephir_fetch_params(1, 3, 0, &query_param, &from_param, &to_param);

	if (unlikely(Z_TYPE_P(query_param) != IS_STRING && Z_TYPE_P(query_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'query' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(query_param) == IS_STRING)) {
		zephir_get_strval(query, query_param);
	} else {
		ZEPHIR_INIT_VAR(query);
		ZVAL_EMPTY_STRING(query);
	}
	if (unlikely(Z_TYPE_P(from_param) != IS_STRING && Z_TYPE_P(from_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'from' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(from_param) == IS_STRING)) {
		zephir_get_strval(from, from_param);
	} else {
		ZEPHIR_INIT_VAR(from);
		ZVAL_EMPTY_STRING(from);
	}
	if (unlikely(Z_TYPE_P(to_param) != IS_STRING && Z_TYPE_P(to_param) != IS_NULL)) {
		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'to' must be a string") TSRMLS_CC);
		RETURN_MM_NULL();
	}
	if (likely(Z_TYPE_P(to_param) == IS_STRING)) {
		zephir_get_strval(to, to_param);
	} else {
		ZEPHIR_INIT_VAR(to);
		ZVAL_EMPTY_STRING(to);
	}


	ZEPHIR_INIT_VAR(args);
	array_init(args);
	ZEPHIR_INIT_NVAR(args);
	zephir_create_array(args, 5, 0 TSRMLS_CC);
	zephir_array_update_string(&args, SL("q"), &query, PH_COPY | PH_SEPARATE);
	ZEPHIR_OBS_VAR(_0);
	zephir_read_property_this(&_0, this_ptr, SL("app_id"), PH_NOISY_CC);
	zephir_array_update_string(&args, SL("appid"), &_0, PH_COPY | PH_SEPARATE);
	ZEPHIR_SINIT_VAR(_1);
	ZVAL_LONG(&_1, 10000);
	ZEPHIR_SINIT_VAR(_2);
	ZVAL_LONG(&_2, 99999);
	ZEPHIR_CALL_FUNCTION(&_3, "rand", NULL, 1, &_1, &_2);
	zephir_check_call_status();
	zephir_array_update_string(&args, SL("salt"), &_3, PH_COPY | PH_SEPARATE);
	zephir_array_update_string(&args, SL("from"), &from, PH_COPY | PH_SEPARATE);
	zephir_array_update_string(&args, SL("to"), &to, PH_COPY | PH_SEPARATE);
	zephir_array_fetch_string(&_4, args, SL("salt"), PH_NOISY | PH_READONLY, "transbybd/transApi.zep", 33 TSRMLS_CC);
	ZEPHIR_CALL_METHOD(&_3, this_ptr, "__buildsign", NULL, 2, query, _4);
	zephir_check_call_status();
	zephir_array_update_string(&args, SL("sign"), &_3, PH_COPY | PH_SEPARATE);
	ZEPHIR_CALL_METHOD(&ret, this_ptr, "__callmutil", NULL, 3, args);
	zephir_check_call_status();
	ZEPHIR_INIT_VAR(_5);
	zephir_json_decode(_5, &(_5), ret, zephir_get_intval(ZEPHIR_GLOBAL(global_true))  TSRMLS_CC);
	ZEPHIR_CPY_WRT(ret, _5);
	RETURN_CCTOR(ret);

}