gio/gresolver.override

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * pygobject - Python bindings for GObject
   3  * Copyright (C) 2009  Gian Mario Tagliaretti
   4  *
   5  *   gresolver.override: module overrides for GResolver
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  20  * USA
  21  */
  22 %%
  23 override g_resolver_lookup_by_name kwargs
  24 static PyObject *
  25 _wrap_g_resolver_lookup_by_name(PyGObject *self,
  26                                 PyObject *args,
  27                                 PyObject *kwargs)
  28 {
  29     static char *kwlist[] = { "hostname", "cancellable", NULL };
  30     gchar *hostname;
  31     PyGObject *pycancellable = NULL;
  32     GCancellable *cancellable;
  33     GList *addr;
  34     GError *error = NULL;
  35     PyObject *ret;
  36
  37     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
  38                                     "s|O:gio.Resolver.lookup_by_name",
  39                                     kwlist,
  40                                     &hostname,
  41                                     &pycancellable))
  42         return NULL;
  43
  44     if (!pygio_check_cancellable(pycancellable, &cancellable))
  45         return NULL;
  46
  47     addr = g_resolver_lookup_by_name(G_RESOLVER(self->obj),
  48                                      hostname, cancellable, &error);
  49
  50     if (addr) {
  51         PYLIST_FROMGLIST(ret, addr, pygobject_new(list_item), g_resolver_free_addresses, NULL);
  52         return ret;
  53     } else {
  54         Py_INCREF(Py_None);
  55         return Py_None;
  56     }
  57 }
  58 %%
  59 override g_resolver_lookup_by_name_async kwargs
  60 static PyObject *
  61 _wrap_g_resolver_lookup_by_name_async(PyGObject *self,
  62                                       PyObject *args,
  63                                       PyObject *kwargs)
  64 {
  65     static char *kwlist[] = { "callback", "hostname",
  66                               "cancellable", "user_data", NULL };
  67     PyGIONotify *notify;
  68     gchar *hostname;
  69     PyGObject *py_cancellable = NULL;
  70     GCancellable *cancellable;
  71
  72     notify = pygio_notify_new();
  73
  74     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
  75                                      "Os|OO:gio.Resolver.lookup_by_name_async",
  76                                      kwlist,
  77                                      &notify->callback,
  78                                      &hostname,
  79                                      &py_cancellable,
  80                                      &notify->data))
  81         goto error;
  82
  83     if (!pygio_notify_callback_is_valid(notify))
  84         goto error;
  85
  86     if (!pygio_check_cancellable(py_cancellable, &cancellable))
  87         goto error;
  88
  89     pygio_notify_reference_callback(notify);
  90
  91     g_resolver_lookup_by_name_async(G_RESOLVER(self->obj),
  92                           hostname,
  93                           cancellable,
  94                           (GAsyncReadyCallback) async_result_callback_marshal,
  95                           notify);
  96
  97     Py_INCREF(Py_None);
  98     return Py_None;
  99
 100  error:
 101     pygio_notify_free(notify);
 102     return NULL;
 103 }
 104 %%
 105 override g_resolver_lookup_by_name_finish kwargs
 106 static PyObject *
 107 _wrap_g_resolver_lookup_by_name_finish(PyGObject *self,
 108                                        PyObject *args,
 109                                        PyObject *kwargs)
 110 {
 111     static char *kwlist[] = { "result", NULL };
 112     PyGObject *result;
 113     GList *addr;
 114     PyObject *ret;
 115     GError *error = NULL;
 116
 117     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 118                                      "O!:gio.Resolver.lookup_by_name_finish",
 119                                      kwlist,
 120                                      &PyGAsyncResult_Type,
 121                                      &result))
 122         return NULL;
 123
 124     addr = g_resolver_lookup_by_name_finish(G_RESOLVER(self->obj),
 125                                             G_ASYNC_RESULT(result->obj),
 126                                             &error);
 127
 128     if (pyg_error_check(&error))
 129         return NULL;
 130
 131     if (addr) {
 132         PYLIST_FROMGLIST(ret, addr, pygobject_new(list_item),
 133                          g_resolver_free_addresses, NULL);
 134         return ret;
 135     } else {
 136         Py_INCREF(Py_None);
 137         return Py_None;
 138     }
 139 }
 140 %%
 141 override g_resolver_lookup_by_address_async kwargs
 142 static PyObject *
 143 _wrap_g_resolver_lookup_by_address_async(PyGObject *self,
 144                                          PyObject *args,
 145                                          PyObject *kwargs)
 146 {
 147     static char *kwlist[] = { "callback", "address",
 148                               "cancellable", "user_data", NULL };
 149     PyGIONotify *notify;
 150     PyGObject *address;
 151     PyGObject *py_cancellable = NULL;
 152     GCancellable *cancellable;
 153
 154     notify = pygio_notify_new();
 155
 156     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 157                                      "OO|OO:gio.Resolver.lookup_by_address_async",
 158                                      kwlist,
 159                                      &notify->callback,
 160                                      &address,
 161                                      &py_cancellable,
 162                                      &notify->data))
 163         goto error;
 164
 165     if (!pygio_notify_callback_is_valid(notify))
 166         goto error;
 167
 168     if (!pygio_check_cancellable(py_cancellable, &cancellable))
 169         goto error;
 170
 171     pygio_notify_reference_callback(notify);
 172
 173     g_resolver_lookup_by_address_async(G_RESOLVER(self->obj),
 174                           G_INET_ADDRESS(address->obj),
 175                           cancellable,
 176                           (GAsyncReadyCallback) async_result_callback_marshal,
 177                           notify);
 178
 179     Py_INCREF(Py_None);
 180     return Py_None;
 181
 182  error:
 183     pygio_notify_free(notify);
 184     return NULL;
 185 }
 186 %%
 187 override g_resolver_lookup_service kwargs
 188 static PyObject *
 189 _wrap_g_resolver_lookup_service(PyGObject *self,
 190                                 PyObject *args,
 191                                 PyObject *kwargs)
 192 {
 193     static char *kwlist[] = { "service", "protocol",
 194                               "domain", "cancellable", NULL };
 195     gchar *service, *protocol, *domain;
 196     PyGObject *pycancellable = NULL;
 197     GCancellable *cancellable;
 198     GList *targets;
 199     GError *error = NULL;
 200     PyObject *ret;
 201
 202     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 203                                     "sss|O:gio.Resolver.lookup_service",
 204                                     kwlist,
 205                                     &service,
 206                                     &protocol,
 207                                     &domain,
 208                                     &pycancellable))
 209         return NULL;
 210
 211     if (!pygio_check_cancellable(pycancellable, &cancellable))
 212         return NULL;
 213
 214     targets = g_resolver_lookup_service(G_RESOLVER(self->obj),
 215                                         service, protocol, domain,
 216                                         cancellable, &error);
 217
 218     if (targets) {
 219         PYLIST_FROMGLIST(ret, targets,
 220                         pyg_boxed_new(G_TYPE_SRV_TARGET, list_item, TRUE, TRUE),
 221                         g_resolver_free_targets, NULL);
 222         return ret;
 223     } else {
 224         Py_INCREF(Py_None);
 225         return Py_None;
 226     }
 227 }
 228 %%
 229 override g_resolver_lookup_service_async kwargs
 230 static PyObject *
 231 _wrap_g_resolver_lookup_service_async(PyGObject *self,
 232                                       PyObject *args,
 233                                       PyObject *kwargs)
 234 {
 235     static char *kwlist[] = { "callback", "service", "protocol", "domain"
 236                               "cancellable", "user_data", NULL };
 237     PyGIONotify *notify;
 238     gchar *service, *protocol, *domain;
 239     PyGObject *py_cancellable = NULL;
 240     GCancellable *cancellable;
 241
 242     notify = pygio_notify_new();
 243
 244     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 245                                     "Osss|OO:gio.Resolver.lookup_service_async",
 246                                     kwlist,
 247                                     &notify->callback,
 248                                     &service,
 249                                     &protocol,
 250                                     &domain,
 251                                     &py_cancellable,
 252                                     &notify->data))
 253         goto error;
 254
 255     if (!pygio_notify_callback_is_valid(notify))
 256         goto error;
 257
 258     if (!pygio_check_cancellable(py_cancellable, &cancellable))
 259         goto error;
 260
 261     pygio_notify_reference_callback(notify);
 262
 263     g_resolver_lookup_service_async(G_RESOLVER(self->obj),
 264                           service, protocol, domain,
 265                           cancellable,
 266                           (GAsyncReadyCallback) async_result_callback_marshal,
 267                           notify);
 268
 269     Py_INCREF(Py_None);
 270     return Py_None;
 271
 272  error:
 273     pygio_notify_free(notify);
 274     return NULL;
 275 }