| Current File : //usr/share/pygobject27/2.0/defs/gsocket.override |
/* -*- Mode: C; c-basic-offset: 4 -*-
* pygobject - Python bindings for GObject
* Copyright (C) 2009 Gian Mario Tagliaretti
*
* gsocket.override: module overrides for GSocket and related types
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
%%
override g_socket_condition_check kwargs
static PyObject *
_wrap_g_socket_condition_check(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "condition", NULL };
gint condition, ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"i:gio.Socket.condition_check",
kwlist, &condition))
return NULL;
ret = g_socket_condition_check(G_SOCKET(self->obj), condition);
return pyg_flags_from_gtype(G_TYPE_IO_CONDITION, ret);
}
%%
override g_socket_condition_wait kwargs
static PyObject *
_wrap_g_socket_condition_wait(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "condition", "cancellable", NULL };
gboolean ret;
gint condition;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
GError *error;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"i|O:gio.Socket.condition_wait",
kwlist, &condition, &cancellable))
return NULL;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
return NULL;
ret = g_socket_condition_wait(G_SOCKET(self->obj), condition,
cancellable, &error);
return PyBool_FromLong(ret);
}
%%
override g_socket_address_enumerator_next_async kwargs
static PyObject *
_wrap_g_socket_address_enumerator_next_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O|OO:gio.SocketAddressEnumerator.next_async",
kwlist,
¬ify->callback,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_address_enumerator_next_async(G_SOCKET_ADDRESS_ENUMERATOR(self->obj),
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_client_connect_async kwargs
static PyObject *
_wrap_g_socket_client_connect_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "connectable", "cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
PyGObject *py_connectable;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"OO|OO:gio.SocketClient.connect_async",
kwlist,
¬ify->callback,
&py_connectable,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_client_connect_async(G_SOCKET_CLIENT(self->obj),
G_SOCKET_CONNECTABLE(py_connectable->obj),
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_client_connect_to_host_async kwargs
static PyObject *
_wrap_g_socket_client_connect_to_host_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "host_and_port", "default_port",
"cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
gchar *host_and_port;
guint16 default_port;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"OsH|OO:gio.SocketClient.connect_to_host_async",
kwlist,
¬ify->callback,
&host_and_port,
&default_port,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_client_connect_to_host_async(G_SOCKET_CLIENT(self->obj),
host_and_port, default_port,
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_client_connect_to_service_async kwargs
static PyObject *
_wrap_g_socket_client_connect_to_service_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "domain", "service",
"cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
gchar *domain, *service;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"Oss|OO:gio.SocketClient.connect_to_service_async",
kwlist,
¬ify->callback,
&domain,
&service,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_client_connect_to_service_async(G_SOCKET_CLIENT(self->obj),
domain, service,
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_listener_add_address kwargs
static PyObject *
_wrap_g_socket_listener_add_address(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "address", "type", "protocol",
"source_object", NULL };
GSocketProtocol protocol;
PyObject *py_type = NULL, *py_protocol = NULL;
GError *error = NULL;
gboolean ret;
GSocketType type;
GSocketAddress *effective_address;
PyGObject *address, *py_source_object = NULL;
GObject *source_object;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!OO|O!:gio.SocketListener.add_address",
kwlist,
&PyGSocketAddress_Type, &address,
&py_type, &py_protocol,
&PyGObject_Type, &source_object,
&PyGSocketAddress_Type, &effective_address))
return NULL;
if (pyg_enum_get_value(G_TYPE_SOCKET_TYPE, py_type, (gpointer)&type))
return NULL;
if (pyg_enum_get_value(G_TYPE_SOCKET_PROTOCOL, py_protocol, (gpointer)&protocol))
return NULL;
if (py_source_object == NULL || (PyObject*)py_source_object == Py_None)
source_object = NULL;
else if (pygobject_check(py_source_object, &PyGObject_Type))
source_object = G_OBJECT(py_source_object->obj);
else {
PyErr_SetString(PyExc_TypeError, "source_object should be a gobject.GObject or None");
return NULL;
}
ret = g_socket_listener_add_address(G_SOCKET_LISTENER(self->obj),
G_SOCKET_ADDRESS(address->obj),
type, protocol,
source_object,
&effective_address,
&error);
if (pyg_error_check(&error))
return NULL;
if (ret)
return pygobject_new((GObject *)effective_address);
else {
Py_INCREF(Py_None);
return Py_None;
}
}
%%
override g_socket_listener_accept kwargs
static PyObject *
_wrap_g_socket_listener_accept(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "cancellable", NULL };
GError *error = NULL;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
PyObject *py_connection, *py_source_object;
GObject *source_object;
GSocketConnection *connection;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"|O:gio.SocketListener.accept",
kwlist,
&py_cancellable))
return NULL;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
return NULL;
connection = g_socket_listener_accept(G_SOCKET_LISTENER(self->obj),
&source_object,
cancellable,
&error);
if (pyg_error_check(&error))
return NULL;
if (connection)
py_connection = pygobject_new((GObject *)connection);
else {
py_connection = Py_None;
Py_INCREF(py_connection);
}
if (source_object)
py_source_object = pygobject_new((GObject *)source_object);
else {
py_source_object= Py_None;
Py_INCREF(py_source_object);
}
return Py_BuildValue("(NN)", py_connection, py_source_object);
}
%%
override g_socket_listener_accept_async kwargs
static PyObject *
_wrap_g_socket_listener_accept_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O|OO:gio.SocketListener.accept_async",
kwlist,
¬ify->callback,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_listener_accept_async(G_SOCKET_LISTENER(self->obj),
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_listener_accept_finish kwargs
static PyObject *
_wrap_g_socket_listener_accept_finish(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "result", NULL };
GError *error = NULL;
PyGObject *result;
PyObject *py_connection, *py_source_object;
GObject *source_object;
GSocketConnection *connection;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:gio.SocketListener.accept_finish",
kwlist,
&PyGAsyncResult_Type, &result))
return NULL;
connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(self->obj),
G_ASYNC_RESULT(result->obj),
&source_object,
&error);
if (pyg_error_check(&error))
return NULL;
if (connection)
py_connection = pygobject_new((GObject *)connection);
else {
py_connection = Py_None;
Py_INCREF(py_connection);
}
if (source_object)
py_source_object = pygobject_new((GObject *)source_object);
else {
py_source_object= Py_None;
Py_INCREF(py_source_object);
}
return Py_BuildValue("(NN)", py_connection, py_source_object);
}
%%
override g_socket_listener_accept_socket kwargs
static PyObject *
_wrap_g_socket_listener_accept_socket(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "cancellable", NULL };
GError *error = NULL;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
PyObject *py_socket, *py_source_object;
GObject *source_object;
GSocket *socket;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"|O:gio.SocketListener.accept_socket",
kwlist,
&py_cancellable))
return NULL;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
return NULL;
socket = g_socket_listener_accept_socket(G_SOCKET_LISTENER(self->obj),
&source_object,
cancellable,
&error);
if (pyg_error_check(&error))
return NULL;
if (socket)
py_socket = pygobject_new((GObject *)socket);
else {
py_socket = Py_None;
Py_INCREF(py_socket);
}
if (source_object)
py_source_object = pygobject_new((GObject *)source_object);
else {
py_source_object= Py_None;
Py_INCREF(py_source_object);
}
return Py_BuildValue("(NN)", py_socket, py_source_object);
}
%%
override g_socket_listener_accept_socket_async kwargs
static PyObject *
_wrap_g_socket_listener_accept_socket_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "cancellable", "user_data", NULL };
PyGIONotify *notify;
PyGObject *py_cancellable = NULL;
GCancellable *cancellable;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O|OO:gio.SocketListener.accept_socket_async",
kwlist,
¬ify->callback,
&py_cancellable,
¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(py_cancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_socket_listener_accept_socket_async(G_SOCKET_LISTENER(self->obj),
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_socket_listener_accept_socket_finish kwargs
static PyObject *
_wrap_g_socket_listener_accept_socket_finish(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "result", NULL };
GError *error = NULL;
PyGObject *result;
PyObject *py_socket, *py_source_object;
GObject *source_object;
GSocket *socket;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:gio.SocketListener.accept_socket_finish",
kwlist,
&PyGAsyncResult_Type, &result))
return NULL;
socket = g_socket_listener_accept_socket_finish(G_SOCKET_LISTENER(self->obj),
G_ASYNC_RESULT(result->obj),
&source_object,
&error);
if (pyg_error_check(&error))
return NULL;
if (socket)
py_socket = pygobject_new((GObject *)socket);
else {
py_socket= Py_None;
Py_INCREF(py_socket);
}
if (source_object)
py_source_object = pygobject_new((GObject *)source_object);
else {
py_source_object= Py_None;
Py_INCREF(py_source_object);
}
return Py_BuildValue("(NN)", py_socket, py_source_object);
}
/* Could not write method GSocketAddress.to_native: No ArgType for gpointer */
/* Could not write method GSocket.receive_from: No ArgType for GSocketAddress** */
/* Could not write method GSocket.receive_message: No ArgType for GSocketAddress** */
/* Could not write method GSocket.send_message: No ArgType for GOutputVector* */
/* Could not write method GSocket.create_source: No ArgType for GIOCondition */
/* Could not write method GSocketControlMessage.serialize: No ArgType for gpointer */
/* Could not write function socket_address_new_from_native: No ArgType for gpointer */
/* Could not write function socket_control_message_deserialize: No ArgType for gpointer */