src/request.c

   1
   2 #include "pool.h"
   3 #include "relation.h"
   4 #include "request.h"
   5 #include "solvable.h"
   6
   7 #include <solv/solver.h>
   8
   9 PyTypeObject RequestType = {
  10         PyObject_HEAD_INIT(NULL)
  11         tp_name: "_pakfire.Request",
  12         tp_basicsize: sizeof(RequestObject),
  13         tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  14         tp_new : Request_new,
  15         tp_dealloc: (destructor) Request_dealloc,
  16         tp_doc: "Sat Request objects",
  17 };
  18
  19 PyObject* Request_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
  20         RequestObject *self;
  21         PoolObject *pool;
  22
  23         if (!PyArg_ParseTuple(args, "O", &pool)) {
  24                 /* XXX raise exception */
  25         }
  26
  27         self = (RequestObject *)type->tp_alloc(type, 0);
  28         if (self != NULL) {
  29                 self->_pool = pool->_pool;
  30                 if (self->_pool == NULL) {
  31                         Py_DECREF(self);
  32                         return NULL;
  33                 }
  34
  35                 queue_init(&self->_queue);
  36         }
  37
  38         return (PyObject *)self;
  39 }
  40
  41 PyObject *Request_dealloc(RequestObject *self) {
  42         self->ob_type->tp_free((PyObject *)self);
  43
  44         Py_RETURN_NONE;
  45 }
  46
  47 void _Request_solvable(RequestObject *self, Id what, Id solvable) {
  48         queue_push(&self->_queue, what|SOLVER_SOLVABLE);
  49         queue_push(&self->_queue, solvable);
  50 }
  51
  52 void _Request_relation(RequestObject *self, Id what, Id relation) {
  53         queue_push(&self->_queue, what|SOLVER_SOLVABLE_PROVIDES);
  54         queue_push(&self->_queue, relation);
  55 }
  56
  57 void _Request_name(RequestObject *self, Id what, Id provides) {
  58         queue_push(&self->_queue, what|SOLVER_SOLVABLE_NAME);
  59         queue_push(&self->_queue, provides);
  60 }
  61
  62 PyObject *Request_install_solvable(RequestObject *self, PyObject *args) {
  63         SolvableObject *solv;
  64
  65         if (!PyArg_ParseTuple(args, "O", &solv)) {
  66                 /* XXX raise exception */
  67         }
  68
  69         _Request_solvable(self, SOLVER_INSTALL, solv->_id);
  70
  71         Py_RETURN_NONE;
  72 }
  73
  74 PyObject *Request_install_relation(RequestObject *self, PyObject *args) {
  75         RelationObject *rel;
  76
  77         if (!PyArg_ParseTuple(args, "O", &rel)) {
  78                 /* XXX raise exception */
  79         }
  80
  81         _Request_relation(self, SOLVER_INSTALL, rel->_id);
  82
  83         Py_RETURN_NONE;
  84 }
  85
  86 PyObject *Request_install_name(RequestObject *self, PyObject *args) {
  87         const char *name;
  88
  89         if (!PyArg_ParseTuple(args, "s", &name)) {
  90                 /* XXX raise exception */
  91         }
  92
  93         Id _name = pool_str2id(self->_pool, name, 1);
  94         _Request_name(self, SOLVER_INSTALL, _name);
  95
  96         Py_RETURN_NONE;
  97 }
  98
  99 PyObject *Request_remove_solvable(RequestObject *self, PyObject *args) {
 100         SolvableObject *solv;
 101
 102         if (!PyArg_ParseTuple(args, "O", &solv)) {
 103                 /* XXX raise exception */
 104         }
 105
 106         _Request_solvable(self, SOLVER_ERASE, solv->_id);
 107
 108         Py_RETURN_NONE;
 109 }
 110
 111 PyObject *Request_remove_relation(RequestObject *self, PyObject *args) {
 112         RelationObject *rel;
 113
 114         if (!PyArg_ParseTuple(args, "O", &rel)) {
 115                 /* XXX raise exception */
 116         }
 117
 118         _Request_relation(self, SOLVER_ERASE, rel->_id);
 119
 120         Py_RETURN_NONE;
 121 }
 122
 123 PyObject *Request_remove_name(RequestObject *self, PyObject *args) {
 124         const char *name;
 125
 126         if (!PyArg_ParseTuple(args, "s", &name)) {
 127                 /* XXX raise exception */
 128         }
 129
 130         Id _name = pool_str2id(self->_pool, name, 1);
 131         _Request_name(self, SOLVER_ERASE, _name);
 132
 133         Py_RETURN_NONE;
 134 }
 135
 136 PyObject *Request_update_solvable(RequestObject *self, PyObject *args) {
 137         SolvableObject *solv;
 138
 139         if (!PyArg_ParseTuple(args, "O", &solv)) {
 140                 /* XXX raise exception */
 141         }
 142
 143         _Request_solvable(self, SOLVER_UPDATE, solv->_id);
 144
 145         Py_RETURN_NONE;
 146 }
 147
 148 PyObject *Request_update_relation(RequestObject *self, PyObject *args) {
 149         RelationObject *rel;
 150
 151         if (!PyArg_ParseTuple(args, "O", &rel)) {
 152                 /* XXX raise exception */
 153         }
 154
 155         _Request_relation(self, SOLVER_UPDATE, rel->_id);
 156
 157         Py_RETURN_NONE;
 158 }
 159
 160 PyObject *Request_update_name(RequestObject *self, PyObject *args) {
 161         const char *name;
 162
 163         if (!PyArg_ParseTuple(args, "s", &name)) {
 164                 /* XXX raise exception */
 165         }
 166
 167         Id _name = pool_str2id(self->_pool, name, 1);
 168         _Request_name(self, SOLVER_UPDATE, _name);
 169
 170         Py_RETURN_NONE;
 171 }
 172
 173 PyObject *Request_lock_solvable(RequestObject *self, PyObject *args) {
 174         SolvableObject *solv;
 175
 176         if (!PyArg_ParseTuple(args, "O", &solv)) {
 177                 /* XXX raise exception */
 178         }
 179
 180         _Request_solvable(self, SOLVER_LOCK, solv->_id);
 181
 182         Py_RETURN_NONE;
 183 }
 184
 185 PyObject *Request_lock_relation(RequestObject *self, PyObject *args) {
 186         RelationObject *rel;
 187
 188         if (!PyArg_ParseTuple(args, "O", &rel)) {
 189                 /* XXX raise exception */
 190         }
 191
 192         _Request_relation(self, SOLVER_LOCK, rel->_id);
 193
 194         Py_RETURN_NONE;
 195 }
 196
 197 PyObject *Request_lock_name(RequestObject *self, PyObject *args) {
 198         const char *name;
 199
 200         if (!PyArg_ParseTuple(args, "s", &name)) {
 201                 /* XXX raise exception */
 202         }
 203
 204         Id _name = pool_str2id(self->_pool, name, 1);
 205         _Request_name(self, SOLVER_LOCK, _name);
 206
 207         Py_RETURN_NONE;
 208 }
 209
 210 PyObject *Request_noobsoletes_solvable(RequestObject *self, PyObject *args) {
 211         SolvableObject *solv;
 212
 213         if (!PyArg_ParseTuple(args, "O", &solv)) {
 214                 /* XXX raise exception */
 215         }
 216
 217         _Request_solvable(self, SOLVER_NOOBSOLETES, solv->_id);
 218
 219         Py_RETURN_NONE;
 220 }
 221
 222 PyObject *Request_noobsoletes_relation(RequestObject *self, PyObject *args) {
 223         RelationObject *rel;
 224
 225         if (!PyArg_ParseTuple(args, "O", &rel)) {
 226                 /* XXX raise exception */
 227         }
 228
 229         _Request_relation(self, SOLVER_NOOBSOLETES, rel->_id);
 230
 231         Py_RETURN_NONE;
 232 }
 233
 234 PyObject *Request_noobsoletes_name(RequestObject *self, PyObject *args) {
 235         const char *name;
 236
 237         if (!PyArg_ParseTuple(args, "s", &name)) {
 238                 /* XXX raise exception */
 239         }
 240
 241         Id _name = pool_str2id(self->_pool, name, 1);
 242         _Request_name(self, SOLVER_NOOBSOLETES, _name);
 243
 244         Py_RETURN_NONE;
 245 }