/**
* Return the strategy to obtain the meta-data
*
* @return Phalcon\Mvc\Model\MetaData\Strategy\Introspection
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, getStrategy){
zval *strategy;
strategy = phalcon_fetch_nproperty_this(this_ptr, SL("_strategy"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(strategy) == IS_NULL) {
PHALCON_ALLOC_GHOST_ZVAL(strategy);
object_init_ex(strategy, phalcon_mvc_model_metadata_strategy_introspection_ce);
phalcon_update_property_this(this_ptr, SL("_strategy"), strategy TSRMLS_CC);
}
RETURN_ZVAL(strategy, 1, 0);
}
/**
* Magic method to retrieve a variable passed to the view
*
*<code>
* echo $this->view->products;
*</code>
*
* @param string $key
* @return mixed
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, __get){
zval *key, *params, *value;
phalcon_fetch_params(0, 1, 0, &key);
params = phalcon_fetch_nproperty_this(this_ptr, SL("_viewParams"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_fetch(&value, params, key)) {
RETURN_ZVAL(value, 1, 0);
}
RETURN_NULL();
}
PHP_METHOD(DefaultTable, compactionStrategyOptions)
{
cassandra_table* self;
zval* value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_table*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_cassandra_get_schema_field(self->meta, "compaction_strategy_options", &value TSRMLS_CC);
RETURN_ZVAL(value, 0, 1);
}
PHP_METHOD(DefaultTable, memtableFlushPeriodMs)
{
cassandra_table* self;
zval* value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_table*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_cassandra_get_schema_field(self->meta, "memtable_flush_period_in_ms", &value TSRMLS_CC);
RETURN_ZVAL(value, 0, 1);
}
//call the service
PHP_METHOD(air_async_service, call) {
AIR_INIT_THIS;
zval *waiter = zend_read_property(air_async_service_ce, self, ZEND_STRL("_waiter"), 0 TSRMLS_CC);
zval *self_id = zend_read_property(air_async_service_ce, self, ZEND_STRL("_id"), 0 TSRMLS_CC);
zval *ret = NULL;
zend_call_method_with_1_params(&waiter, Z_OBJCE_P(waiter), NULL, "response", &ret, self_id);
if(ret){
RETURN_ZVAL(ret, 1, 1);
}else{
RETURN_NULL();
}
}
/**
* Returns the internal formatter
*
* @return Phalcon\Logger\FormatterInterface
*/
PHP_METHOD(Phalcon_Logger_Adapter_Firephp, getFormatter){
zval *formatter;
formatter = phalcon_read_property(getThis(), SL("_formatter"), PH_NOISY);
if (Z_TYPE_P(formatter) != IS_OBJECT) {
object_init_ex(return_value, phalcon_logger_formatter_firephp_ce);
phalcon_update_property_this(getThis(), SL("_formatter"), return_value);
return;
}
RETURN_ZVAL(formatter, 1, 0);
}
PHP_METHOD(DefaultTable, name)
{
cassandra_table* self;
zval* value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_table*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_cassandra_get_schema_field(self->meta, "columnfamily_name", &value TSRMLS_CC);
RETURN_ZVAL(value, 0, 1);
}
PHP_METHOD(DefaultTable, gcGraceSeconds)
{
cassandra_table* self;
zval* value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_table*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_cassandra_get_schema_field(self->meta, "gc_grace_seconds", &value TSRMLS_CC);
RETURN_ZVAL(value, 0, 1);
}
PHP_METHOD(DefaultTable, bloomFilterFPChance)
{
cassandra_table* self;
zval* value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_table*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_cassandra_get_schema_field(self->meta, "bloom_filter_fp_chance", &value TSRMLS_CC);
RETURN_ZVAL(value, 0, 1);
}
/* {{{ proto SimpleXMLIterator SimpleXMLIterator::getChildren()
Get child element iterator */
PHP_METHOD(ce_SimpleXMLIterator, getChildren)
{
php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
return; /* return NULL */
}
RETURN_ZVAL(&sxe->iter.data, 1, 0);
}
/**
* Gets the current element in a zval hash
*/
void zephir_array_get_current(zval *return_value, zval *array) {
zval **entry;
if (Z_TYPE_P(array) == IS_ARRAY) {
if (zend_hash_get_current_data(Z_ARRVAL_P(array), (void **) &entry) == FAILURE) {
RETURN_FALSE;
}
RETURN_ZVAL(*entry, 1, 0);
}
RETURN_FALSE;
}
PHP_METHOD(DefaultTable, caching)
{
cassandra_table *self;
php5to7_zval value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = PHP_CASSANDRA_GET_TABLE(getThis());
php_cassandra_get_table_field(self->meta, "caching", &value TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(value), 0, 1);
}
/* {{{ MongoDBRef::create()
*
* DB refs are of the form:
* array( '$ref' => <collection>, '$id' => <id>[, $db => <dbname>] ) */
PHP_METHOD(MongoDBRef, create)
{
char *ns, *db = NULL;
int ns_len, db_len = 0;
zval *zid, *retval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|s", &ns, &ns_len, &zid, &db, &db_len) == FAILURE) {
return;
}
retval = php_mongo_dbref_create(zid, ns, db TSRMLS_CC);
RETURN_ZVAL(retval, 0, 1);
}
/* {{{ proto SimpleXMLIterator SimpleXMLIterator::getChildren()
Get child element iterator */
PHP_METHOD(ce_SimpleXMLIterator, getChildren)
{
php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
if (!sxe->iter.data || sxe->iter.type == SXE_ITER_ATTRLIST) {
return; /* return NULL */
}
RETURN_ZVAL(sxe->iter.data, 1, 0);
}
ONPHP_METHOD(DBField, toDialectString)
{
smart_str string = {0};
zval *table, *field, *dialect, *cast, *quoted;
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
table = ONPHP_READ_PROPERTY(getThis(), "table");
field = ONPHP_READ_PROPERTY(getThis(), "field");
cast = ONPHP_READ_PROPERTY(getThis(), "cast");
// either null or instance of DialectString
if (Z_TYPE_P(table) == IS_OBJECT) {
zval *tmp;
ONPHP_CALL_METHOD_1(table, "todialectstring", &tmp, dialect);
onphp_append_zval_to_smart_string(&string, tmp);
zval_ptr_dtor(&tmp);
smart_str_appendc(&string, '.');
}
ONPHP_CALL_METHOD_1(dialect, "quotefield", "ed, field);
onphp_append_zval_to_smart_string(&string, quoted);
zval_ptr_dtor("ed);
smart_str_0(&string);
if (Z_STRLEN_P(cast)) {
zval *tmp, *out;
ALLOC_INIT_ZVAL(tmp);
ZVAL_STRINGL(tmp, string.c, string.len, 1);
ONPHP_CALL_METHOD_2_NORET(dialect, "tocasted", &out, tmp, cast);
ZVAL_FREE(tmp);
smart_str_free(&string);
if (EG(exception)) {
return;
}
RETURN_ZVAL(out, 1, 1);
}
RETURN_STRINGL(string.c, string.len, 0);
}
/* {{{ proto string|array Riak\MapReduce\Input\BucketInput->getValue()
Returns value to use in Mapreduce */
PHP_METHOD(Riak_MapReduce_Input_BucketInput, getValue)
{
zval* zname, *zfilters, *zresult, *zindex;
zname = zend_read_property(riak_mrinput_bucket_ce, getThis(), "name", sizeof("name")-1, 1 TSRMLS_CC);
zfilters = zend_read_property(riak_mrinput_bucket_ce, getThis(), "keyFilters", sizeof("keyFilters")-1, 1 TSRMLS_CC);
zindex = zend_read_property(riak_mrinput_bucket_ce, getThis(), "idxname", sizeof("idxname")-1, 1 TSRMLS_CC);
if (Z_TYPE_P(zfilters) == IS_ARRAY || Z_TYPE_P(zindex) == IS_STRING) {
MAKE_STD_ZVAL(zresult);
array_init(zresult);
zval_addref_p(zname);
add_assoc_zval_ex(zresult, "bucket", sizeof("bucket"), zname);
if (Z_TYPE_P(zindex) == IS_STRING) {
zval *start, *end;
start = zend_read_property(riak_mrinput_bucket_ce, getThis(), "idxstart", sizeof("idxstart")-1, 1 TSRMLS_CC);
end = zend_read_property(riak_mrinput_bucket_ce, getThis(), "idxend", sizeof("idxend")-1, 1 TSRMLS_CC);
zval_addref_p(zindex);
add_assoc_zval_ex(zresult, "index", sizeof("index"), zindex);
if (Z_TYPE_P(end) != IS_STRING) {
zval_addref_p(start);
add_assoc_zval_ex(zresult, "key", sizeof("key"), start);
} else {
zval_addref_p(start);
zval_addref_p(end);
add_assoc_zval_ex(zresult, "start", sizeof("start"), start);
add_assoc_zval_ex(zresult, "end", sizeof("end"), end);
}
}
if (Z_TYPE_P(zfilters) == IS_ARRAY) {
zval_addref_p(zfilters);
add_assoc_zval_ex(zresult, "key_filters", sizeof("key_filters"), zfilters);
}
RETURN_ZVAL(zresult, 0, 1);
} else {
RETURN_ZVAL(zname, 1, 0);
}
}
/*{{{ public Fool_Application::run(void)
*/
PHP_METHOD(fool_application,run)
{
zval* response;
zval* dispatcher;
zval* self = getThis();
dispatcher = zend_read_property(fool_application_ce,self,ZEND_STRL(FOOL_APPLICATION_PROPERTY_NAME_DISPATCHER),1 TSRMLS_CC);
if((response = fool_dispatcher_dispatch(dispatcher TSRMLS_CC))){
RETURN_ZVAL(response,1,1);
}
RETURN_FALSE;
}
PHP_METHOD(Rows, current)
{
zval **entry;
cassandra_rows* self = NULL;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC);
if (zend_hash_get_current_data(Z_ARRVAL_P(self->rows), (void **) &entry) == SUCCESS)
RETURN_ZVAL(*entry, 1, 0);
}
ONPHP_METHOD(Ternary, spawn)
{
zval *value, *true, *false, *null, *result, *out;
ONPHP_GET_ARGS("zzz|z", &value, &true, &false, &null);
ALLOC_INIT_ZVAL(result);
ONPHP_MAKE_OBJECT(Ternary, out);
if (ZEND_NUM_ARGS() == 3) {
ALLOC_INIT_ZVAL(null);
ZVAL_NULL(null);
}
if (
is_identical_function(result, value, true TSRMLS_CC)
&& (zval_is_true(result))
) {
ONPHP_UPDATE_PROPERTY_BOOL(out, "trinity", 1);
} else if (
is_identical_function(result, value, false TSRMLS_CC)
&& (zval_is_true(result))
) {
ONPHP_UPDATE_PROPERTY_BOOL(out, "trinity", 0);
} else if (
(
is_identical_function(result, value, null TSRMLS_CC)
&& (zval_is_true(result))
) || (
Z_TYPE_P(null) == IS_NULL
)
) {
ONPHP_UPDATE_PROPERTY_NULL(out, "trinity");
} else {
ONPHP_THROW_NORET(WrongArgumentException, "failed to spawn Ternary");
}
ZVAL_FREE(result);
if (ZEND_NUM_ARGS() == 3) {
ZVAL_FREE(null);
}
if (EG(exception)) {
return;
}
RETURN_ZVAL(out, 1, 1);
}
/**
* Magic __get method
*
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Http_Uri, __get){
zval *key, *parts, *value = NULL;
phalcon_fetch_params(0, 1, 0, &key);
parts = phalcon_read_property(getThis(), SL("_parts"), PH_NOISY);
if (!phalcon_array_isset_fetch(&value, parts, key)) {
RETURN_NULL();
}
RETURN_ZVAL(value, 1, 0);
}
/* {{{ proto SimpleXMLIterator SimpleXMLIterator::current()
Get current element */
PHP_METHOD(ce_SimpleXMLIterator, current)
{
php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
if (Z_ISUNDEF(sxe->iter.data)) {
return; /* return NULL */
}
RETURN_ZVAL(&sxe->iter.data, 1, 0);
}
/**
* Creates/Returns a collection of resources
*
* @param string $name
* @return Phalcon\Assets\Collection
*/
PHP_METHOD(Phalcon_Assets_Manager, collection){
zval *name, *collections, *collection = NULL;
phalcon_fetch_params(0, 1, 0, &name);
collections = phalcon_fetch_nproperty_this(this_ptr, SL("_collections"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_fetch(&collection, collections, name)) {
RETURN_ZVAL(collection, 1, 0);
}
object_init_ex(return_value, phalcon_assets_collection_ce);
phalcon_update_property_array(this_ptr, SL("_collections"), name, return_value TSRMLS_CC);
}
/**
* Returns a Phalcon\DI\Service instance
*
* @param string $name
* @return Phalcon\DI\ServiceInterface
*/
PHP_METHOD(Phalcon_DI, getService){
zval *name, *service;
phalcon_fetch_params(0, 1, 0, &name);
PHALCON_ENSURE_IS_STRING(name);
if (phalcon_isset_property_array(getThis(), SL("_services"), name)) {
service = phalcon_read_property_array(getThis(), SL("_services"), name);
RETURN_ZVAL(service, 1, 0);
}
zend_throw_exception_ex(phalcon_di_exception_ce, 0, "Service '%s' was not found in the dependency injection container", Z_STRVAL_P(name));
}
SKYRAY_METHOD(HttpRequest, getUri)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
skyray_http_request_t *intern = skyray_http_request_from_obj(Z_OBJ_P(getThis()));
if (ZVAL_IS_NULL(&intern->uri)) {
RETURN_STRING("/");
} else {
RETURN_ZVAL(&intern->uri, 1, 0);
}
}
/* {{{ MongoCursor::timeout
*/
PHP_METHOD(MongoCursor, timeout) {
long timeout;
mongo_cursor *cursor;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout) == FAILURE) {
return;
}
PHP_MONGO_GET_CURSOR(getThis());
cursor->timeout = timeout;
RETURN_ZVAL(getThis(), 1, 0);
}
/**
* Gets query string which request has been made
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getQueryString){
zval *value, *_SERVER, key = {};
PHALCON_STR(&key, "QUERY_STRING");
_SERVER = phalcon_get_global_str(SS("_SERVER") TSRMLS_CC);
value = (Z_TYPE_P(_SERVER) == IS_ARRAY) ? phalcon_hash_get(Z_ARRVAL_P(_SERVER), &key, BP_VAR_UNSET) : NULL;
if (value && Z_TYPE_P(value) == IS_STRING) {
RETURN_ZVAL(value, 1, 0);
}
RETURN_EMPTY_STRING();
}
SKYRAY_METHOD(HttpRequest, setQueryParams)
{
zval *params;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", ¶ms) == FAILURE) {
return;
}
skyray_http_request_t *intern = skyray_http_request_from_obj(Z_OBJ_P(getThis()));
zval_dtor(&intern->query_params);
ZVAL_COPY(&intern->query_params, params);
RETURN_ZVAL(getThis(), 1, 0);
}
/**
* Gets HTTP URI which request has been made
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getURI){
zval *value, *_SERVER, key = {};
PHALCON_STR(&key, "REQUEST_URI");
_SERVER = phalcon_get_global_str(SL("_SERVER"));
value = (Z_TYPE_P(_SERVER) == IS_ARRAY) ? phalcon_hash_get(Z_ARRVAL_P(_SERVER), &key, BP_VAR_UNSET) : NULL;
if (value && Z_TYPE_P(value) == IS_STRING) {
RETURN_ZVAL(value, 1, 0);
}
RETURN_EMPTY_STRING();
}
/**
* Escapes HTML replacing special chars by entities
*/
void phalcon_escape_html(zval *return_value, zval *str, const zval *quote_style, const zval *charset) {
zend_string *escaped;
if (Z_TYPE_P(str) != IS_STRING) {
/* Nothing to escape */
RETURN_ZVAL(str, 1, 0);
}
if (Z_TYPE_P(quote_style) != IS_LONG) {
php_error_docref(NULL, E_WARNING, "Invalid quote_style supplied for phalcon_escape_html()");
RETURN_ZVAL(str, 1, 0);
}
if (Z_TYPE_P(charset) != IS_STRING) {
php_error_docref(NULL, E_WARNING, "Invalid charset supplied for phalcon_escape_html()");
RETURN_ZVAL(str, 1, 0);
}
escaped = php_escape_html_entities((unsigned char*) Z_STRVAL_P(str), Z_STRLEN_P(str), 0, Z_LVAL_P(quote_style), Z_STRVAL_P(charset));
RETURN_STR(escaped);
}
/** {{{ public ZeActiveString::clear()
*/
PHP_METHOD(ze_activestring, clear) {
zval * self = NULL;
zval * actives = NULL;
self = getThis();
actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC);
zend_hash_clean(Z_ARRVAL_P(actives));
zend_update_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), actives TSRMLS_CC);
RETURN_ZVAL(self, 1, 0);
}
