src/request.c

   1
   2 #include "pool.h"
   3 #include "relation.h"
   4 #include "request.h"
   5 #include "solvable.h"
   6
   7 #include <satsolver/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
  45 void _Request_solvable(RequestObject *self, Id what, Id solvable) {
  46         queue_push(&self->_queue, what|SOLVER_SOLVABLE);
  47         queue_push(&self->_queue, solvable);
  48 }
  49
  50 void _Request_relation(RequestObject *self, Id what, Id relation) {
  51         queue_push(&self->_queue, what|SOLVER_SOLVABLE_PROVIDES);
  52         queue_push(&self->_queue, relation);
  53 }
  54
  55 void _Request_name(RequestObject *self, Id what, Id provides) {
  56         queue_push(&self->_queue, what|SOLVER_SOLVABLE_NAME);
  57         queue_push(&self->_queue, provides);
  58 }
  59
  60 PyObject *Request_install_solvable(RequestObject *self, PyObject *args) {
  61         SolvableObject *solv;
  62
  63         if (!PyArg_ParseTuple(args, "O", &solv)) {
  64                 /* XXX raise exception */
  65         }
  66
  67         _Request_solvable(self, SOLVER_INSTALL, solv->_id);
  68
  69         Py_RETURN_NONE;
  70 }
  71
  72 PyObject *Request_install_relation(RequestObject *self, PyObject *args) {
  73         RelationObject *rel;
  74
  75         if (!PyArg_ParseTuple(args, "O", &rel)) {
  76                 /* XXX raise exception */
  77         }
  78
  79         _Request_relation(self, SOLVER_INSTALL, rel->_id);
  80
  81         Py_RETURN_NONE;
  82 }
  83
  84 PyObject *Request_install_name(RequestObject *self, PyObject *args) {
  85         const char *name;
  86
  87         if (!PyArg_ParseTuple(args, "s", &name)) {
  88                 /* XXX raise exception */
  89         }
  90
  91         Id _name = pool_str2id(self->_pool, name, 1);
  92         _Request_name(self, SOLVER_INSTALL, _name);
  93
  94         Py_RETURN_NONE;
  95 }
  96
  97 PyObject *Request_remove_solvable(RequestObject *self, PyObject *args) {
  98         SolvableObject *solv;
  99
 100         if (!PyArg_ParseTuple(args, "O", &solv)) {
 101                 /* XXX raise exception */
 102         }
 103
 104         _Request_solvable(self, SOLVER_ERASE, solv->_id);
 105
 106         Py_RETURN_NONE;
 107 }
 108
 109 PyObject *Request_remove_relation(RequestObject *self, PyObject *args) {
 110         RelationObject *rel;
 111
 112         if (!PyArg_ParseTuple(args, "O", &rel)) {
 113                 /* XXX raise exception */
 114         }
 115
 116         _Request_relation(self, SOLVER_ERASE, rel->_id);
 117
 118         Py_RETURN_NONE;
 119 }
 120
 121 PyObject *Request_remove_name(RequestObject *self, PyObject *args) {
 122         const char *name;
 123
 124         if (!PyArg_ParseTuple(args, "s", &name)) {
 125                 /* XXX raise exception */
 126         }
 127
 128         Id _name = pool_str2id(self->_pool, name, 1);
 129         _Request_name(self, SOLVER_ERASE, _name);
 130
 131         Py_RETURN_NONE;
 132 }
 133
 134 PyObject *Request_update_solvable(RequestObject *self, PyObject *args) {
 135         SolvableObject *solv;
 136
 137         if (!PyArg_ParseTuple(args, "O", &solv)) {
 138                 /* XXX raise exception */
 139         }
 140
 141         _Request_solvable(self, SOLVER_UPDATE, solv->_id);
 142
 143         Py_RETURN_NONE;
 144 }
 145
 146 PyObject *Request_update_relation(RequestObject *self, PyObject *args) {
 147         RelationObject *rel;
 148
 149         if (!PyArg_ParseTuple(args, "O", &rel)) {
 150                 /* XXX raise exception */
 151         }
 152
 153         _Request_relation(self, SOLVER_UPDATE, rel->_id);
 154
 155         Py_RETURN_NONE;
 156 }
 157
 158 PyObject *Request_update_name(RequestObject *self, PyObject *args) {
 159         const char *name;
 160
 161         if (!PyArg_ParseTuple(args, "s", &name)) {
 162                 /* XXX raise exception */
 163         }
 164
 165         Id _name = pool_str2id(self->_pool, name, 1);
 166         _Request_name(self, SOLVER_UPDATE, _name);
 167
 168         Py_RETURN_NONE;
 169 }
 170
 171 PyObject *Request_lock_solvable(RequestObject *self, PyObject *args) {
 172         SolvableObject *solv;
 173
 174         if (!PyArg_ParseTuple(args, "O", &solv)) {
 175                 /* XXX raise exception */
 176         }
 177
 178         _Request_solvable(self, SOLVER_LOCK, solv->_id);
 179
 180         Py_RETURN_NONE;
 181 }
 182
 183 PyObject *Request_lock_relation(RequestObject *self, PyObject *args) {
 184         RelationObject *rel;
 185
 186         if (!PyArg_ParseTuple(args, "O", &rel)) {
 187                 /* XXX raise exception */
 188         }
 189
 190         _Request_relation(self, SOLVER_LOCK, rel->_id);
 191
 192         Py_RETURN_NONE;
 193 }
 194
 195 PyObject *Request_lock_name(RequestObject *self, PyObject *args) {
 196         const char *name;
 197
 198         if (!PyArg_ParseTuple(args, "s", &name)) {
 199                 /* XXX raise exception */
 200         }
 201
 202         Id _name = pool_str2id(self->_pool, name, 1);
 203         _Request_name(self, SOLVER_LOCK, _name);
 204
 205         Py_RETURN_NONE;
 206 }