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

static PHP_METHOD(swoole_server_port, getSocket){    swListenPort *port = swoole_get_object(getThis());    php_socket *socket_object = swoole_convert_to_socket(port->sock);    if (!socket_object)    {        RETURN_FALSE;    }    SW_ZEND_REGISTER_RESOURCE(return_value, (void *) socket_object, php_sockets_le_socket());    zval *zsocket = sw_zval_dup(return_value);    sw_zval_add_ref(&zsocket);}

static PHP_METHOD(swoole_redis, __destruct){    swRedisClient *redis = swoole_get_object(getThis());    if (!redis)    {        return;    }    if (redis->state != SWOOLE_REDIS_STATE_CLOSED)    {        redisAsyncDisconnect(redis->context);    }    efree(redis);}

static PHP_METHOD(swoole_ringqueue, pop){    swRingQueue *queue = swoole_get_object(getThis());    zval *zdata;    int n = swRingQueue_pop(queue, (void**)&zdata);    if (n < 0)    {        RETURN_FALSE;    }    RETVAL_ZVAL(zdata, 0, 0);    efree(zdata);}

static PHP_METHOD( swoole_websocket_server, on){    zval *callback;    zval *event_name;    if (SwooleGS->start > 0)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server is running. Unable to set event callback now.");        RETURN_FALSE;    }    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_name, &callback) == FAILURE)    {        return;    }    swServer *serv = swoole_get_object(getThis());    char *func_name = NULL;    if (!sw_zend_is_callable(callback, 0, &func_name TSRMLS_CC))    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Function '%s' is not callable", func_name);        efree(func_name);        RETURN_FALSE;    }    efree(func_name);#if PHP_MAJOR_VERSION >= 7    zval *callback_copy = emalloc(sizeof(zval));    memcpy(callback_copy, callback, sizeof(zval));    callback = callback_copy;#endif    serv->open_websocket_protocol = 1;    if (strncasecmp("open", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        sw_zval_add_ref(&callback);        websocket_callbacks[0] = callback;    }    else if (strncasecmp("message", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        sw_zval_add_ref(&callback);        websocket_callbacks[1] = callback;    }    else    {        zval *obj = getThis();        sw_zend_call_method_with_2_params(&obj, swoole_http_server_class_entry_ptr, NULL, "on", &return_value, event_name, callback);    }}

static PHP_METHOD(swoole_table, set){    zval *array;    char *key;    zend_size_t keylen;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &keylen, &array) == FAILURE)    {        RETURN_FALSE;    }    swTable *table = swoole_get_object(getThis());    sw_atomic_t *_lock = NULL;    swTableRow *row = swTableRow_set(table, key, keylen, &_lock);    if (!row)    {        sw_spinlock_release(_lock);        swoole_php_error(E_WARNING, "Unable to allocate memory.");        RETURN_FALSE;    }    swTableColumn *col;    zval *v;    char *k;    uint32_t klen;    int ktype;    HashTable *_ht = Z_ARRVAL_P(array);    SW_HASHTABLE_FOREACH_START2(_ht, k, klen, ktype, v)    {        col = swTableColumn_get(table, k, klen);        if (k == NULL || col == NULL)        {            continue;        }        else if (col->type == SW_TABLE_STRING)        {            convert_to_string(v);            swTableRow_set_value(row, col, Z_STRVAL_P(v), Z_STRLEN_P(v));        }        else if (col->type == SW_TABLE_FLOAT)        {            convert_to_double(v);            swTableRow_set_value(row, col, &Z_DVAL_P(v), 0);        }        else        {            convert_to_long(v);            swTableRow_set_value(row, col, &Z_LVAL_P(v), 0);        }    }

static PHP_METHOD(swoole_mysql, close){    mysql_client *client = swoole_get_object(getThis());    if (!client)    {        swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_mysql.");        RETURN_FALSE;    }    if (!client->cli)    {        swoole_php_fatal_error(E_WARNING, "mysql connection#%d is closed.", client->fd);        RETURN_FALSE;    }    zend_update_property_bool(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("connected"), 0 TSRMLS_CC);    SwooleG.main_reactor->del(SwooleG.main_reactor, client->fd);    swConnection *socket = swReactor_get(SwooleG.main_reactor, client->fd);    socket->object = NULL;    zend_bool is_destroyed = client->cli->destroyed;    //close the connection    client->cli->close(client->cli);    //release client object memory    swClient_free(client->cli);    efree(client->cli);    client->cli = NULL;    zval *retval = NULL;    zval **args[1];    zval *object = getThis();    if (client->onClose)    {        args[0] = &object;        if (sw_call_user_function_ex(EG(function_table), NULL, client->onClose, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS)        {            swoole_php_fatal_error(E_WARNING, "swoole_mysql onClose callback error.");        }        if (retval)        {            sw_zval_ptr_dtor(&retval);        }    }    if (!is_destroyed)    {        sw_zval_ptr_dtor(&object);    }}

static PHP_METHOD(swoole_redis, close){    swRedisClient *redis = swoole_get_object(getThis());    if (redis && redis->context && redis->state != SWOOLE_REDIS_STATE_CLOSED)    {        if (redis->connecting)        {            SwooleG.main_reactor->defer(SwooleG.main_reactor, redis_close, redis);        }        else        {            redis_close(redis);        }    }}

static void http_client_coro_onConnect(swClient *cli){#if PHP_MAJOR_VERSION < 7    TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);#endif    zval *zobject = cli->object;    http_client *http = swoole_get_object(zobject);    if (!http->cli)    {        swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_http_client_coro.");        return;    }    http_client_coro_send_http_request(zobject TSRMLS_CC);}

static PHP_METHOD(swoole_table, create){    swTable *table = swoole_get_object(getThis());    if (table->memory)    {        swoole_php_fatal_error(E_WARNING, "The table have beed created.");        RETURN_FALSE;    }    if (swTable_create(table) < 0)    {        swoole_php_fatal_error(E_ERROR, "Unable to allocate memory.");        RETURN_FALSE;    }    RETURN_TRUE;}

static PHP_METHOD(swoole_msgqueue, stats){    swMsgQueue *queue = swoole_get_object(getThis());    int queue_num = -1;    int queue_bytes = -1;    if (swMsgQueue_stat(queue, &queue_num, &queue_bytes) == 0)    {        array_init(return_value);        add_assoc_long_ex(return_value, ZEND_STRL("queue_num"), queue_num);        add_assoc_long_ex(return_value, ZEND_STRL("queue_bytes"), queue_bytes);    }    else    {        RETURN_FALSE;    }}

static PHP_METHOD(swoole_buffer, expand){    long size = -1;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE)    {        RETURN_FALSE;    }    swString *buffer = swoole_get_object(getThis());    if (size <= buffer->size)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "new size must more than %ld", buffer->size);        RETURN_FALSE;    }    zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("capacity"), size TSRMLS_CC);    SW_CHECK_RETURN(swString_extend(buffer, size));}

static PHP_METHOD(swoole_process, freeQueue){    swWorker *process = swoole_get_object(getThis());    if (process->queue)    {        process->queue->remove = 1;        swMsgQueue_free(process->queue);        efree(process->queue);        process->queue = NULL;        RETURN_TRUE;    }    else    {        RETURN_FALSE;    }}

static PHP_METHOD(swoole_process, __destruct){    swWorker *process = swoole_get_object(getThis());    swPipe *_pipe = process->pipe_object;    if (_pipe)    {        _pipe->close(_pipe);        efree(_pipe);    }    if (process->queue)    {        process->queue->free(process->queue);        efree(process->queue);    }    efree(process);}

PHP_METHOD(swoole_atomic_long, set){    sw_atomic_long_t *atomic = swoole_get_object(getThis());    zend_long set_value;#ifdef FAST_ZPP    ZEND_PARSE_PARAMETERS_START(1, 1)        Z_PARAM_LONG(set_value)    ZEND_PARSE_PARAMETERS_END();#else    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &set_value) == FAILURE)    {        RETURN_FALSE;    }#endif    *atomic = (sw_atomic_long_t) set_value;}

static PHP_METHOD(swoole_coroutine_iterator, valid){    coroutine_iterator *itearator = swoole_get_object(getThis());    int cid = itearator->current_cid;    for (; itearator->count > 0 && cid < MAX_CORO_NUM_LIMIT + 1; cid++)    {        if (coroutine_get_by_id(cid))        {            itearator->current_cid = cid;            itearator->index++;            itearator->count--;            RETURN_TRUE;        }    }    RETURN_FALSE;}

static PHP_METHOD(swoole_redis, close){    swRedisClient *redis = swoole_get_object(getThis());    if (redis && redis->context)    {        if (redis->connecting)        {            swoole_php_fatal_error(E_WARNING, "redis client is connecting, cannot close.");            RETURN_FALSE;        }        else if (redis->state != SWOOLE_REDIS_STATE_CLOSED)        {            redisAsyncDisconnect(redis->context);        }    }}

static void http_client_coro_onTimeout(php_context *ctx){#if PHP_MAJOR_VERSION < 7    TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);#endif    zval *zdata;    zval *retval = NULL;    SW_MAKE_STD_ZVAL(zdata);    ZVAL_BOOL(zdata, 0); //return false#if PHP_MAJOR_VERSION < 7    zval *zobject = (zval *)ctx->coro_params;#else    zval _zobject = ctx->coro_params;    zval *zobject = & _zobject;#endif    //define time out RETURN ERROR  110    zend_update_property_long(swoole_http_client_coro_class_entry_ptr, zobject, ZEND_STRL("errCode"), 110 TSRMLS_CC);    http_client *http = swoole_get_object(zobject);    http->cli->released = 1;    http_client_free(zobject TSRMLS_CC);    swoole_set_object(zobject, NULL);    http_client_property *hcc = swoole_get_property(zobject, 0);    if(hcc->defer && hcc->defer_status != HTTP_CLIENT_STATE_DEFER_WAIT){        hcc->defer_status = HTTP_CLIENT_STATE_DEFER_DONE;        hcc->defer_result = 0;        goto free_zdata;    }    hcc->defer_status = HTTP_CLIENT_STATE_DEFER_INIT;    int ret = coro_resume(ctx, zdata, &retval);    if (ret > 0)    {        goto free_zdata;    }    if (retval != NULL)    {        sw_zval_ptr_dtor(&retval);    }free_zdata:    sw_zval_ptr_dtor(&zdata);}

static int swoole_redis_send_command(zval *object, zval *callback, char *format, ...){#if PHP_MAJOR_VERSION < 7    TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);#endif    swRedisClient *redis = swoole_get_object(object);    switch (redis->state)    {    case SWOOLE_REDIS_STATE_CONNECT:        swoole_php_error(E_WARNING, "redis client is not connected.");        return SW_ERR;    case SWOOLE_REDIS_STATE_WAIT:        swoole_php_error(E_WARNING, "redis client is waiting for response.");        return SW_ERR;    case SWOOLE_REDIS_STATE_CLOSED:        swoole_php_error(E_WARNING, "redis client connection is closed.");        return SW_ERR;    default:        break;    }#if PHP_MAJOR_VERSION < 7    redis->result_callback = callback;#else    redis->result_callback = &redis->_result_callback;    memcpy(redis->result_callback, callback, sizeof(zval));#endif    sw_zval_add_ref(&redis->result_callback);    va_list ap;    va_start(ap, format);    int ret = redisvAsyncCommand(redis->context, swoole_redis_onResult, NULL, format, ap);    va_end(ap);    if (ret < 0)    {        swoole_php_error(E_WARNING, "redisAsyncCommandArgv() failed.");        return SW_ERR;    }    redis->state = SWOOLE_REDIS_STATE_WAIT;    return SW_OK;}

PHP_METHOD(swoole_table, column){    char *name;    zend_size_t len;    long type;    long size;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &name, &len, &type, &size) == FAILURE)    {        RETURN_FALSE;    }    if (type == SW_TABLE_STRING && size < 1)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "string length must be more than 0.");        RETURN_FALSE;    }    swTable *table = swoole_get_object(getThis());    swTableColumn_add(table, name, len, type, size);    RETURN_TRUE;}

static PHP_METHOD(swoole_mysql, __destruct){    mysql_client *client = swoole_get_object(getThis());    if (!client)    {        swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_mysql.");        RETURN_FALSE;    }//    if (client->state != SW_MYSQL_STATE_CLOSED)//    {//        zval *retval;//        sw_zend_call_method_with_0_params(&getThis(), swoole_mysql_class_entry_ptr, NULL, "close", &retval);//        if (retval)//        {//            sw_zval_ptr_dtor(&retval);//        }//    }    efree(client);    swoole_set_object(getThis(), NULL);}

static PHP_METHOD(swoole_redis, on){    char *name;    zend_size_t len;    zval *cb;    if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "sz", &name, &len, &cb) == FAILURE)    {        return;    }    swRedisClient *redis = swoole_get_object(getThis());    if (redis->context != NULL)    {        swoole_php_fatal_error(E_WARNING, "Must be called before connect.");        RETURN_FALSE;    }    if (strncasecmp("close", name, len) == 0)    {        zend_update_property(swoole_redis_class_entry_ptr, getThis(), ZEND_STRL("onClose"), cb TSRMLS_CC);        redis->close_callback = sw_zend_read_property(swoole_redis_class_entry_ptr,  getThis(), ZEND_STRL("onClose"), 0 TSRMLS_CC);        sw_copy_to_stack(redis->close_callback, redis->_close_callback);    }    else if (strncasecmp("message", name, len) == 0)    {        zend_update_property(swoole_redis_class_entry_ptr, getThis(), ZEND_STRL("onMessage"), cb TSRMLS_CC);        redis->message_callback = sw_zend_read_property(swoole_redis_class_entry_ptr,  getThis(), ZEND_STRL("onMessage"), 0 TSRMLS_CC);        sw_copy_to_stack(redis->message_callback, redis->_message_callback);        redis->subscribe = 1;    }    else    {        swoole_php_error(E_WARNING, "Unknown event type[%s]", name);        RETURN_FALSE;    }    RETURN_TRUE;}