typewrappers.c

   1 /*
   2  * types.c: converter functions between the internal representation
   3  *          and the Python objects
   4  *
   5  * Copyright (C) 2005, 2007 Red Hat, Inc.
   6  *
   7  * Daniel Veillard <veillard@redhat.com>
   8  */
   9
  10 #include <config.h>
  11
  12 /* Horrible kludge to work around even more horrible name-space pollution
  13  *    via Python.h.  That file includes /usr/include/python2.5/pyconfig*.h,
  14  *       which has over 180 autoconf-style HAVE_* definitions.  Shame on them.  */
  15 #undef HAVE_PTHREAD_H
  16
  17 #include "typewrappers.h"
  18
  19 PyObject *
  20 libvirt_intWrap(int val)
  21 {
  22     PyObject *ret;
  23     ret = PyInt_FromLong((long) val);
  24     return (ret);
  25 }
  26
  27 PyObject *
  28 libvirt_longWrap(long val)
  29 {
  30     PyObject *ret;
  31     ret = PyInt_FromLong(val);
  32     return (ret);
  33 }
  34
  35 PyObject *
  36 libvirt_ulongWrap(unsigned long val)
  37 {
  38     PyObject *ret;
  39     ret = PyLong_FromLong(val);
  40     return (ret);
  41 }
  42
  43 PyObject *
  44 libvirt_longlongWrap(long long val)
  45 {
  46     PyObject *ret;
  47     ret = PyLong_FromUnsignedLongLong((unsigned long long) val);
  48     return (ret);
  49 }
  50
  51 PyObject *
  52 libvirt_charPtrWrap(char *str)
  53 {
  54     PyObject *ret;
  55
  56     if (str == NULL) {
  57         Py_INCREF(Py_None);
  58         return (Py_None);
  59     }
  60     ret = PyString_FromString(str);
  61     free(str);
  62     return (ret);
  63 }
  64
  65 PyObject *
  66 libvirt_constcharPtrWrap(const char *str)
  67 {
  68     PyObject *ret;
  69
  70     if (str == NULL) {
  71         Py_INCREF(Py_None);
  72         return (Py_None);
  73     }
  74     ret = PyString_FromString(str);
  75     return (ret);
  76 }
  77
  78 PyObject *
  79 libvirt_charPtrConstWrap(const char *str)
  80 {
  81     PyObject *ret;
  82
  83     if (str == NULL) {
  84         Py_INCREF(Py_None);
  85         return (Py_None);
  86     }
  87     ret = PyString_FromString(str);
  88     return (ret);
  89 }
  90
  91 PyObject *
  92 libvirt_virDomainPtrWrap(virDomainPtr node)
  93 {
  94     PyObject *ret;
  95
  96     if (node == NULL) {
  97         Py_INCREF(Py_None);
  98         return (Py_None);
  99     }
 100     ret =
 101         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virDomainPtr",
 102                                      NULL);
 103     return (ret);
 104 }
 105
 106 PyObject *
 107 libvirt_virNetworkPtrWrap(virNetworkPtr node)
 108 {
 109     PyObject *ret;
 110
 111     if (node == NULL) {
 112         Py_INCREF(Py_None);
 113         return (Py_None);
 114     }
 115     ret =
 116         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virNetworkPtr",
 117                                      NULL);
 118     return (ret);
 119 }
 120
 121 PyObject *
 122 libvirt_virInterfacePtrWrap(virInterfacePtr node)
 123 {
 124     PyObject *ret;
 125
 126     if (node == NULL) {
 127         Py_INCREF(Py_None);
 128         return (Py_None);
 129     }
 130     ret =
 131         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virInterfacePtr",
 132                                      NULL);
 133     return (ret);
 134 }
 135
 136 PyObject *
 137 libvirt_virStoragePoolPtrWrap(virStoragePoolPtr node)
 138 {
 139     PyObject *ret;
 140
 141     if (node == NULL) {
 142         Py_INCREF(Py_None);
 143         return (Py_None);
 144     }
 145     ret =
 146         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virStoragePoolPtr",
 147                                      NULL);
 148     return (ret);
 149 }
 150
 151 PyObject *
 152 libvirt_virStorageVolPtrWrap(virStorageVolPtr node)
 153 {
 154     PyObject *ret;
 155
 156     if (node == NULL) {
 157         Py_INCREF(Py_None);
 158         return (Py_None);
 159     }
 160     ret =
 161         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virStorageVolPtr",
 162                                      NULL);
 163     return (ret);
 164 }
 165
 166 PyObject *
 167 libvirt_virConnectPtrWrap(virConnectPtr node)
 168 {
 169     PyObject *ret;
 170
 171     if (node == NULL) {
 172         Py_INCREF(Py_None);
 173         return (Py_None);
 174     }
 175     ret =
 176         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virConnectPtr",
 177                                      NULL);
 178     return (ret);
 179 }
 180
 181 PyObject *
 182 libvirt_virNodeDevicePtrWrap(virNodeDevicePtr node)
 183 {
 184     PyObject *ret;
 185
 186     if (node == NULL) {
 187         Py_INCREF(Py_None);
 188         return (Py_None);
 189     }
 190     ret =
 191         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virNodeDevicePtr",
 192                                      NULL);
 193     return (ret);
 194 }
 195
 196 PyObject *
 197 libvirt_virSecretPtrWrap(virSecretPtr node)
 198 {
 199     PyObject *ret;
 200
 201     if (node == NULL) {
 202         Py_INCREF(Py_None);
 203         return Py_None;
 204     }
 205     ret = PyCObject_FromVoidPtrAndDesc(node, (char *) "virSecretPtr", NULL);
 206     return (ret);
 207 }
 208
 209 PyObject *
 210 libvirt_virStreamPtrWrap(virStreamPtr node)
 211 {
 212     PyObject *ret;
 213
 214     if (node == NULL) {
 215         Py_INCREF(Py_None);
 216         return Py_None;
 217     }
 218     ret = PyCObject_FromVoidPtrAndDesc(node, (char *) "virStreamPtr", NULL);
 219     return (ret);
 220 }
 221
 222 PyObject *
 223 libvirt_virEventHandleCallbackWrap(virEventHandleCallback node)
 224 {
 225     PyObject *ret;
 226
 227     if (node == NULL) {
 228         Py_INCREF(Py_None);
 229         printf("%s: WARNING - Wrapping None\n", __func__);
 230         return (Py_None);
 231     }
 232     ret =
 233         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virEventHandleCallback",
 234                                      NULL);
 235     return (ret);
 236 }
 237
 238 PyObject *
 239 libvirt_virEventTimeoutCallbackWrap(virEventTimeoutCallback node)
 240 {
 241     PyObject *ret;
 242
 243     if (node == NULL) {
 244         printf("%s: WARNING - Wrapping None\n", __func__);
 245         Py_INCREF(Py_None);
 246         return (Py_None);
 247     }
 248     ret =
 249         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virEventTimeoutCallback",
 250                                      NULL);
 251     return (ret);
 252 }
 253
 254 PyObject *
 255 libvirt_virFreeCallbackWrap(virFreeCallback node)
 256 {
 257     PyObject *ret;
 258
 259     if (node == NULL) {
 260         Py_INCREF(Py_None);
 261         return (Py_None);
 262     }
 263     ret =
 264         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virFreeCallback",
 265                                      NULL);
 266     return (ret);
 267 }
 268
 269 PyObject *
 270 libvirt_virVoidPtrWrap(void* node)
 271 {
 272     PyObject *ret;
 273
 274     if (node == NULL) {
 275         Py_INCREF(Py_None);
 276         return (Py_None);
 277     }
 278     ret =
 279         PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "void*",
 280                                      NULL);
 281     return (ret);
 282 }