bindings/solv.i

   1 /*
   2  * WARNING: for perl iterator/array support you need to run
   3  *   sed -i -e 's/SvTYPE(tsv) == SVt_PVHV/SvTYPE(tsv) == SVt_PVHV || SvTYPE(tsv) == SVt_PVAV/'
   4  * on the generated c code
   5  */
   6
   7 %module solv
   8
   9 #ifdef SWIGRUBY
  10 %markfunc Pool "mark_Pool";
  11 #endif
  12
  13 /**
  14  ** binaryblob handling
  15  **/
  16
  17 %{
  18 typedef struct {
  19   const void *data;
  20   size_t len;
  21 } BinaryBlob;
  22 %}
  23
  24 %typemap(in,noblock=1,fragment="SWIG_AsCharPtrAndSize") (const unsigned char *str, size_t len) (int res, char *buf = 0, size_t size = 0, int alloc = 0) {
  25 #if defined(SWIGTCL)
  26   {
  27     int bal;
  28     unsigned char *ba;
  29     res = SWIG_TypeError;
  30     ba = Tcl_GetByteArrayFromObj($input, &bal);
  31     if (ba) {
  32       buf = (char *)ba;
  33       size = bal;
  34       res = SWIG_OK;
  35       alloc = SWIG_OLDOBJ;
  36     }
  37   }
  38 #else
  39   res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
  40   if (buf && size)
  41     size--;
  42 #endif
  43   if (!SWIG_IsOK(res)) {
  44 #if defined(SWIGPYTHON)
  45     const void *pybuf = 0;
  46     Py_ssize_t pysize = 0;
  47 %#if PY_VERSION_HEX >= 0x03000000
  48     res = PyBytes_AsStringAndSize($input, (char **)&pybuf, &pysize);
  49 %#else
  50     res = PyObject_AsReadBuffer($input, &pybuf, &pysize);
  51 %#endif
  52     if (res < 0) {
  53       %argument_fail(res, "BinaryBlob", $symname, $argnum);
  54     } else {
  55       buf = (void *)pybuf;
  56       size = pysize;
  57     }
  58 #else
  59     %argument_fail(res, "const char *", $symname, $argnum);
  60 #endif
  61   }
  62   $1 = (unsigned char *)buf;
  63   $2 = size;
  64 }
  65
  66 %typemap(freearg,noblock=1,match="in") (const unsigned char *str, int len) {
  67   if (alloc$argnum == SWIG_NEWOBJ) %delete_array(buf$argnum);
  68 }
  69
  70 %typemap(out,noblock=1,fragment="SWIG_FromCharPtrAndSize") BinaryBlob {
  71 #if defined(SWIGPYTHON) && defined(PYTHON3)
  72   $result = $1.data ? Py_BuildValue("y#", $1.data, $1.len) : SWIG_Py_Void();
  73 #elif defined(SWIGTCL)
  74   Tcl_SetObjResult(interp, $1.data ? Tcl_NewByteArrayObj($1.data, $1.len) : NULL);
  75 #else
  76   $result = SWIG_FromCharPtrAndSize($1.data, $1.len);
  77 #if defined(SWIGPERL)
  78   argvi++;
  79 #endif
  80 #endif
  81 }
  82
  83 /**
  84  ** Queue handling
  85  **/
  86
  87 %typemap(arginit) Queue {
  88   queue_init(&$1);
  89 }
  90 %typemap(freearg) Queue {
  91   queue_free(&$1);
  92 }
  93
  94 #if defined(SWIGPYTHON)
  95
  96 %typemap(out) Queue {
  97   int i;
  98   PyObject *o = PyList_New($1.count);
  99   for (i = 0; i < $1.count; i++)
 100     PyList_SetItem(o, i, SWIG_From_int($1.elements[i]));
 101   queue_free(&$1);
 102   $result = o;
 103 }
 104
 105 %define Queue2Array(type, step, con) %{ {
 106   int i;
 107   int cnt = $1.count / step;
 108   Id *idp = $1.elements;
 109   PyObject *o = PyList_New(cnt);
 110   for (i = 0; i < cnt; i++, idp += step)
 111     {
 112       Id id = *idp;
 113 #define result resultx
 114       type result = con;
 115       $typemap(out, type)
 116       PyList_SetItem(o, i, $result);
 117 #undef result
 118     }
 119   queue_free(&$1);
 120   $result = o;
 121 }
 122 %}
 123 %enddef
 124
 125 %define Array2Queue(asval_meth,typestr) %{ {
 126   int i, size;
 127   if (!PyList_Check($input))
 128     SWIG_exception_fail(SWIG_TypeError, "argument $argnum is not a list");
 129   size = PyList_Size($input);
 130   for (i = 0; i < size; i++) {
 131     PyObject *o = PyList_GetItem($input,i);
 132     int v;
 133     int e = asval_meth(o, &v);
 134     if (!SWIG_IsOK(e))
 135       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only" typestr);
 136     queue_push(&$1, v);
 137   }
 138 }
 139 %}
 140 %enddef
 141
 142 %define ObjArray2Queue(type, obj2queue) %{ {
 143   int i, size;
 144   if (!PyList_Check($input))
 145     SWIG_exception_fail(SWIG_TypeError, "argument $argnum is not a list");
 146   size = PyList_Size($input);
 147   for (i = 0; i < size; i++) {
 148     PyObject *o = PyList_GetItem($input,i);
 149     type obj;
 150     int e = SWIG_ConvertPtr(o, (void **)&obj, $descriptor(type), 0 | 0);
 151     if (!SWIG_IsOK(e))
 152       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only "`type`);
 153     obj2queue;
 154   }
 155 }
 156 %}
 157 %enddef
 158
 159 #endif  /* SWIGPYTHON */
 160
 161 #if defined(SWIGPERL)
 162 /* AV *o = newAV();
 163  * av_push(o, SvREFCNT_inc(SWIG_From_int($1.elements[i])));
 164  * $result = newRV_noinc((SV*)o); argvi++;
 165  */
 166 %typemap(out) Queue {
 167   int i;
 168   if (argvi + $1.count + 1 >= items) {
 169     EXTEND(sp, (argvi + $1.count + 1) - items + 1);
 170   }
 171   for (i = 0; i < $1.count; i++)
 172     ST(argvi++) = SvREFCNT_inc(SWIG_From_int($1.elements[i]));
 173   queue_free(&$1);
 174   $result = 0;
 175 }
 176
 177 %define Queue2Array(type, step, con) %{ {
 178   int i;
 179   int cnt = $1.count / step;
 180   Id *idp = $1.elements;
 181   if (argvi + cnt + 1 >= items) {
 182     EXTEND(sp, (argvi + cnt + 1) - items + 1);
 183   }
 184   for (i = 0; i < cnt; i++, idp += step)
 185     {
 186       Id id = *idp;
 187 #define result resultx
 188       type result = con;
 189       $typemap(out, type)
 190       SvREFCNT_inc(ST(argvi - 1));
 191 #undef result
 192     }
 193   queue_free(&$1);
 194   $result = 0;
 195 }
 196 %}
 197 %enddef
 198
 199 %define Array2Queue(asval_meth,typestr) %{ {
 200   AV *av;
 201   int i, size;
 202   if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV)
 203     SWIG_croak("argument $argnum is not an array reference.");
 204   av = (AV*)SvRV($input);
 205   size = av_len(av);
 206   for (i = 0; i <= size; i++) {
 207     SV **sv = av_fetch(av, i, 0);
 208     int v;
 209     int e = asval_meth(*sv, &v);
 210     if (!SWIG_IsOK(e))
 211       SWIG_croak("array in argument $argnum must contain only " typestr);
 212     queue_push(&$1, v);
 213   }
 214 }
 215 %}
 216 %enddef
 217
 218 %define ObjArray2Queue(type, obj2queue) %{ {
 219   AV *av;
 220   int i, size;
 221   if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV)
 222     SWIG_croak("argument $argnum is not an array reference.");
 223   av = (AV*)SvRV($input);
 224   size = av_len(av);
 225   for (i = 0; i <= size; i++) {
 226     SV **sv = av_fetch(av, i, 0);
 227     type obj;
 228     int e = SWIG_ConvertPtr(*sv, (void **)&obj, $descriptor(type), 0 | 0);
 229     if (!SWIG_IsOK(e))
 230       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only "`type`);
 231     obj2queue;
 232   }
 233 }
 234 %}
 235 %enddef
 236
 237 #endif  /* SWIGPERL */
 238
 239
 240 #if defined(SWIGRUBY)
 241 %typemap(out) Queue {
 242   int i;
 243   VALUE o = rb_ary_new2($1.count);
 244   for (i = 0; i < $1.count; i++)
 245     rb_ary_store(o, i, SWIG_From_int($1.elements[i]));
 246   queue_free(&$1);
 247   $result = o;
 248 }
 249
 250 %define Queue2Array(type, step, con) %{ {
 251   int i;
 252   int cnt = $1.count / step;
 253   Id *idp = $1.elements;
 254   VALUE o = rb_ary_new2(cnt);
 255   for (i = 0; i < cnt; i++, idp += step)
 256     {
 257       Id id = *idp;
 258 #define result resultx
 259       type result = con;
 260       $typemap(out, type)
 261       rb_ary_store(o, i, $result);
 262 #undef result
 263     }
 264   queue_free(&$1);
 265   $result = o;
 266 }
 267 %}
 268 %enddef
 269
 270 %define Array2Queue(asval_meth,typestr) %{ {
 271   int size, i;
 272   VALUE *o, ary;
 273   ary = rb_Array($input);
 274   size = RARRAY_LEN(ary);
 275   i = 0;
 276   o = RARRAY_PTR(ary);
 277   for (i = 0; i < size; i++, o++) {
 278     int v;
 279     int e = asval_meth(*o, &v);
 280     if (!SWIG_IsOK(e))
 281       SWIG_exception_fail(SWIG_TypeError, "list in argument $argnum must contain only " typestr);
 282     queue_push(&$1, v);
 283   }
 284 }
 285 %}
 286 %enddef
 287
 288 %define ObjArray2Queue(type, obj2queue) %{ {
 289   int size, i;
 290   VALUE *o, ary;
 291   ary = rb_Array($input);
 292   size = RARRAY_LEN(ary);
 293   i = 0;
 294   o = RARRAY_PTR(ary);
 295   for (i = 0; i < size; i++, o++) {
 296     type obj;
 297     int e = SWIG_ConvertPtr(*o, (void **)&obj, $descriptor(type), 0 | 0);
 298     if (!SWIG_IsOK(e))
 299       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only "`type`);
 300     obj2queue;
 301   }
 302 }
 303 %}
 304 %enddef
 305
 306 #endif  /* SWIGRUBY */
 307
 308 #if defined(SWIGTCL)
 309 %typemap(out) Queue {
 310   Tcl_Obj *objvx[$1.count];
 311   int i;
 312
 313   for (i = 0; i < $1.count; i++) {
 314     objvx[i] = SWIG_From_int($1.elements[i]);
 315   }
 316   Tcl_SetObjResult(interp, Tcl_NewListObj($1.count, objvx));
 317   queue_free(&$1);
 318 }
 319
 320 %define Queue2Array(type, step, con) %{
 321   { /* scope is needed to make the goto of SWIG_exception_fail work */
 322     int i;
 323     int cnt = $1.count / step;
 324     Id *idp = $1.elements;
 325     Tcl_Obj *objvx[cnt];
 326
 327     for (i = 0; i < cnt; i++, idp += step) {
 328       Id id = *idp;
 329 #define result resultx
 330 #define Tcl_SetObjResult(i, x) resultobj = x
 331       type result = con;
 332       Tcl_Obj *resultobj;
 333       $typemap(out, type)
 334       objvx[i] = resultobj;
 335 #undef Tcl_SetObjResult
 336 #undef result
 337     }
 338     queue_free(&$1);
 339     Tcl_SetObjResult(interp, Tcl_NewListObj(cnt, objvx));
 340  }
 341 %}
 342 %enddef
 343
 344 %define Array2Queue(asval_meth,typestr) %{ {
 345   int size = 0;
 346   int i = 0;
 347   if (TCL_OK != Tcl_ListObjLength(interp, $input, &size))
 348     SWIG_exception_fail(SWIG_TypeError, "argument $argnum is not a list");
 349   for (i = 0; i < size; i++) {
 350     Tcl_Obj *o = NULL;
 351     int e, v;
 352
 353     if (TCL_OK != Tcl_ListObjIndex(interp, $input, i, &o))
 354       SWIG_exception_fail(SWIG_IndexError, "failed to retrieve a list member");
 355     e = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(o, &v);
 356     if (!SWIG_IsOK(e))
 357       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only " typestr);
 358     queue_push(&$1, v);
 359   }
 360 }
 361 %}
 362 %enddef
 363
 364 %define ObjArray2Queue(type, obj2queue) %{ {
 365   int size = 0;
 366   int i = 0;
 367   if (TCL_OK != Tcl_ListObjLength(interp, $input, &size))
 368     SWIG_exception_fail(SWIG_TypeError, "argument $argnum is not a list");
 369   for (i = 0; i < size; i++) {
 370     Tcl_Obj *o = NULL;
 371     type obj;
 372     int e;
 373     if (TCL_OK != Tcl_ListObjIndex(interp, $input, i, &o))
 374       SWIG_exception_fail(SWIG_IndexError, "failed to retrieve a list member");
 375     e = SWIG_ConvertPtr(o, (void **)&obj, $descriptor(type), 0 | 0);
 376     if (!SWIG_IsOK(e))
 377       SWIG_exception_fail(SWIG_ArgError(e), "list in argument $argnum must contain only "`type`);
 378     obj2queue;
 379   }
 380 }
 381 %}
 382 %enddef
 383
 384 #endif  /* SWIGTCL */
 385
 386 %typemap(in) Queue Array2Queue(SWIG_AsVal_int, "integers")
 387 %typemap(in) Queue solvejobs ObjArray2Queue(Job *, queue_push2(&$1, obj->how, obj->what))
 388 %typemap(in) Queue solvables ObjArray2Queue(XSolvable *, queue_push(&$1, obj->id))
 389
 390
 391
 392 #if defined(SWIGPERL)
 393
 394 /* work around a swig bug for swig versions < 2.0.5 */
 395 #if SWIG_VERSION < 0x020005
 396 %{
 397 #undef SWIG_CALLXS
 398 #ifdef PERL_OBJECT
 399 #  define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv,pPerl)
 400 #else
 401 #  ifndef MULTIPLICITY
 402 #    define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv)
 403 #  else
 404 #    define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(PERL_GET_THX, cv)
 405 #  endif
 406 #endif
 407 %}
 408 #endif
 409
 410
 411 %define perliter(class)
 412   %perlcode {
 413     sub class##::FETCH {
 414       my $i = ${##class##::ITERATORS}{$_[0]};
 415       if ($i) {
 416         $_[1] == $i->[0] - 1 ? $i->[1] : undef;
 417       } else {
 418         $_[0]->__getitem__($_[1]);
 419       }
 420     }
 421     sub class##::FETCHSIZE {
 422       my $i = ${##class##::ITERATORS}{$_[0]};
 423       if ($i) {
 424         ($i->[1] = $_[0]->__next__()) ? ++$i->[0]  : 0;
 425       } else {
 426         $_[0]->__len__();
 427       }
 428     }
 429   }
 430 %enddef
 431
 432 %{
 433
 434 #define SWIG_PERL_ITERATOR      0x80
 435
 436 SWIGRUNTIMEINLINE SV *
 437 SWIG_Perl_NewArrayObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
 438   SV *result = sv_newmortal();
 439   if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
 440     SV *self;
 441     SV *obj=newSV(0);
 442     AV *array=newAV();
 443     HV *stash;
 444     sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
 445     stash=SvSTASH(SvRV(obj));
 446     if (flags & SWIG_POINTER_OWN) {
 447       HV *hv;
 448       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
 449       if (!isGV(gv))
 450         gv_init(gv, stash, "OWNER", 5, FALSE);
 451       hv=GvHVn(gv);
 452       hv_store_ent(hv, obj, newSViv(1), 0);
 453     }
 454     if (flags & SWIG_PERL_ITERATOR) {
 455       HV *hv;
 456       GV *gv=*(GV**)hv_fetch(stash, "ITERATORS", 9, TRUE);
 457       AV *av=newAV();
 458       if (!isGV(gv))
 459         gv_init(gv, stash, "ITERATORS", 9, FALSE);
 460       hv=GvHVn(gv);
 461       hv_store_ent(hv, obj, newRV_inc((SV *)av), 0);
 462     }
 463     sv_magic((SV *)array, (SV *)obj, 'P', Nullch, 0);
 464     SvREFCNT_dec(obj);
 465     self=newRV_noinc((SV *)array);
 466     sv_setsv(result, self);
 467     SvREFCNT_dec((SV *)self);
 468     sv_bless(result, stash);
 469   } else {
 470     sv_setref_pv(result, (char *) SWIG_Perl_TypeProxyName(t), ptr);
 471   }
 472   return result;
 473 }
 474
 475 %}
 476
 477 %typemap(out) Perlarray {
 478   ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow); argvi++;
 479 }
 480 %typemap(out) Perliterator {
 481   ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow | SWIG_PERL_ITERATOR); argvi++;
 482 }
 483
 484 %typemap(out) Pool_solvable_iterator * = Perlarray;
 485 %typemap(out) Pool_solvable_iterator * solvables_iter = Perliterator;
 486 %typemap(out) Pool_repo_iterator * = Perlarray;
 487 %typemap(out) Pool_repo_iterator * repos_iter = Perliterator;
 488 %typemap(out) Repo_solvable_iterator * = Perlarray;
 489 %typemap(out) Repo_solvable_iterator * solvables_iter = Perliterator;
 490 %typemap(out) Dataiterator * = Perliterator;
 491
 492 #endif  /* SWIGPERL */
 493
 494
 495 /**
 496  ** appdata handling
 497  **/
 498
 499 #if defined(SWIGPYTHON)
 500 typedef PyObject *AppObjectPtr;
 501 %typemap(in) AppObjectPtr {
 502   if ($input)
 503     Py_INCREF($input);
 504   $1 = $input;
 505 }
 506 %typemap(out) AppObjectPtr {
 507   $result = $1 ? $1 : Py_None;
 508   Py_INCREF($result);
 509 }
 510 #elif defined(SWIGPERL)
 511 typedef SV *AppObjectPtr;
 512 %typemap(in) AppObjectPtr {
 513   if ($input) {
 514     $1 = newSV(0);
 515     sv_setsv((SV *)$1, $input);
 516   } else
 517     $1 = (void *)0;
 518 }
 519 %typemap(out) AppObjectPtr {
 520   $result = sv_2mortal($1 ? SvREFCNT_inc($1) : newSV(0));
 521   argvi++;
 522 }
 523 #elif defined(SWIGRUBY)
 524 typedef VALUE AppObjectPtr;
 525 %typemap(in) AppObjectPtr {
 526   $1 = (void *)$input;
 527 }
 528 %typemap(out) AppObjectPtr {
 529   $result = (VALUE)$1;
 530 }
 531 #elif defined(SWIGTCL)
 532 typedef Tcl_Obj *AppObjectPtr;
 533 %typemap(in) AppObjectPtr {
 534   if ($input)
 535     Tcl_IncrRefCount($input);
 536   $1 = (void *)$input;
 537 }
 538 %typemap(out) AppObjectPtr {
 539   Tcl_SetObjResult(interp, $1 ? $1 : Tcl_NewObj());
 540 }
 541 #else
 542 #warning AppObjectPtr not defined for this language!
 543 #endif
 544
 545 /**
 546  ** FILE handling
 547  **/
 548
 549 #ifdef SWIGPYTHON
 550 %include "file.i"
 551 #else
 552 %fragment("SWIG_AsValFilePtr","header") {}
 553 #endif
 554
 555
 556 %fragment("SWIG_AsValSolvFpPtr","header", fragment="SWIG_AsValFilePtr") {
 557
 558 SWIGINTERN int
 559 #ifdef SWIGRUBY
 560 SWIG_AsValSolvFpPtr(VALUE obj, FILE **val) {
 561 #elif defined(SWIGTCL)
 562 SWIG_AsValSolvFpPtr SWIG_TCL_DECL_ARGS_2(void *obj, FILE **val) {
 563 #else
 564 SWIG_AsValSolvFpPtr(void *obj, FILE **val) {
 565 #endif
 566   static swig_type_info* desc = 0;
 567   void *vptr = 0;
 568   int ecode;
 569
 570   if (!desc) desc = SWIG_TypeQuery("SolvFp *");
 571   if ((SWIG_ConvertPtr(obj, &vptr, desc, 0)) == SWIG_OK) {
 572     if (val)
 573       *val = vptr ? ((SolvFp *)vptr)->fp : 0;
 574     return SWIG_OK;
 575   }
 576 #ifdef SWIGPYTHON
 577   ecode = SWIG_AsValFilePtr(obj, val);
 578   if (ecode == SWIG_OK)
 579     return ecode;
 580 #endif
 581   return SWIG_TypeError;
 582 }
 583
 584 #if defined(SWIGTCL)
 585 #define SWIG_AsValSolvFpPtr(x, y) SWIG_AsValSolvFpPtr SWIG_TCL_CALL_ARGS_2(x, y)
 586 #endif
 587
 588 }
 589
 590
 591 /**
 592  ** DepId handling
 593  **/
 594
 595 %fragment("SWIG_AsValDepId","header") {
 596
 597 SWIGINTERN int
 598 #ifdef SWIGRUBY
 599 SWIG_AsValDepId(VALUE obj, int *val) {
 600 #elif defined(SWIGTCL)
 601 SWIG_AsValDepId SWIG_TCL_DECL_ARGS_2(void *obj, int *val) {
 602 #else
 603 SWIG_AsValDepId(void *obj, int *val) {
 604 #endif
 605   static swig_type_info* desc = 0;
 606   void *vptr = 0;
 607   int ecode;
 608   if (!desc) desc = SWIG_TypeQuery("Dep *");
 609 #ifdef SWIGTCL
 610   ecode = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(obj, val);
 611 #else
 612   ecode = SWIG_AsVal_int(obj, val);
 613 #endif
 614   if (SWIG_IsOK(ecode))
 615     return ecode;
 616   if ((SWIG_ConvertPtr(obj, &vptr, desc, 0)) == SWIG_OK) {
 617     if (val)
 618       *val = vptr ? ((Dep *)vptr)->id : 0;
 619     return SWIG_OK;
 620   }
 621   return SWIG_TypeError;
 622 }
 623
 624 #ifdef SWIGTCL
 625 #define SWIG_AsValDepId(x, y) SWIG_AsValDepId SWIG_TCL_CALL_ARGS_2(x, y)
 626 #endif
 627 }
 628
 629 /**
 630  ** Pool disown helper
 631  **/
 632
 633 %typemap(out) disown_helper {
 634 #if defined(SWIGRUBY)
 635   SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Pool, SWIG_POINTER_DISOWN |  0 );
 636 #elif defined(SWIGPYTHON)
 637   SWIG_ConvertPtr($self, &argp1,SWIGTYPE_p_Pool, SWIG_POINTER_DISOWN |  0 );
 638 #elif defined(SWIGPERL)
 639   SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Pool, SWIG_POINTER_DISOWN |  0 );
 640 #elif defined(SWIGTCL)
 641   SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_Pool, SWIG_POINTER_DISOWN | 0);
 642 #else
 643 #warning disown_helper not implemented for this language, this is likely going to leak memory
 644 #endif
 645
 646 #ifdef SWIGTCL
 647   Tcl_SetObjResult(interp, SWIG_From_int((int)(0)));
 648 #else
 649   $result = SWIG_From_int((int)(0));
 650 #endif
 651 }
 652
 653
 654 /**
 655  ** return $self
 656  **/
 657
 658 %define returnself(func)
 659 #if defined(SWIGPYTHON)
 660 %typemap(out) void func {
 661   $result = $self;
 662   Py_INCREF($result);
 663 }
 664 #elif defined(SWIGPERL)
 665 %typemap(out) void func {
 666   $result = sv_2mortal(SvREFCNT_inc(ST(0)));argvi++;
 667 }
 668 #elif defined(SWIGRUBY)
 669 %typemap(ret) void func {
 670   return self;
 671 }
 672 #elif defined(SWIGTCL)
 673 %typemap(out) void func {
 674   Tcl_IncrRefCount(objv[1]);
 675   Tcl_SetObjResult(interp, objv[1]);
 676 }
 677 #endif
 678 %enddef
 679
 680
 681 /**
 682  ** misc stuff
 683  **/
 684
 685 %include "typemaps.i"
 686
 687 %typemap(in,numinputs=0,noblock=1) XRule **OUTPUT ($*1_ltype temp) {
 688   $1 = &temp;
 689 }
 690 %typemap(argout,noblock=1) XRule **OUTPUT {
 691   %append_output(SWIG_NewPointerObj((void*)(*$1), SWIGTYPE_p_XRule, SWIG_POINTER_OWN | %newpointer_flags));
 692 }
 693
 694 %typemaps_asval(%checkcode(POINTER), SWIG_AsValSolvFpPtr, "SWIG_AsValSolvFpPtr", FILE*);
 695 %typemaps_asval(%checkcode(INT32), SWIG_AsValDepId, "SWIG_AsValDepId", DepId);
 696
 697
 698 /**
 699  ** the C declarations
 700  **/
 701
 702 %{
 703 #include <stdbool.h>
 704 #include <stdio.h>
 705 #include <sys/stat.h>
 706 #include <sys/utsname.h>
 707 #include <sys/types.h>
 708 #include <unistd.h>
 709 #include <fcntl.h>
 710
 711 /* argh, swig undefs bool for perl */
 712 #ifndef bool
 713 typedef int bool;
 714 #endif
 715
 716 #include "pool.h"
 717 #include "poolarch.h"
 718 #include "evr.h"
 719 #include "solver.h"
 720 #include "policy.h"
 721 #include "solverdebug.h"
 722 #include "repo_solv.h"
 723 #include "chksum.h"
 724 #include "selection.h"
 725
 726 #include "repo_write.h"
 727 #if defined(ENABLE_RPMDB) || defined(ENABLE_RPMPKG)
 728 #include "repo_rpmdb.h"
 729 #endif
 730 #ifdef ENABLE_PUBKEY
 731 #include "repo_pubkey.h"
 732 #endif
 733 #ifdef ENABLE_DEBIAN
 734 #include "repo_deb.h"
 735 #endif
 736 #ifdef ENABLE_RPMMD
 737 #include "repo_rpmmd.h"
 738 #include "repo_updateinfoxml.h"
 739 #include "repo_deltainfoxml.h"
 740 #include "repo_repomdxml.h"
 741 #endif
 742 #ifdef ENABLE_SUSEREPO
 743 #include "repo_products.h"
 744 #include "repo_susetags.h"
 745 #include "repo_content.h"
 746 #endif
 747 #ifdef ENABLE_MDKREPO
 748 #include "repo_mdk.h"
 749 #endif
 750 #ifdef ENABLE_ARCHREPO
 751 #include "repo_arch.h"
 752 #endif
 753 #ifdef SUSE
 754 #include "repo_autopattern.h"
 755 #endif
 756 #if defined(ENABLE_COMPLEX_DEPS) && (defined(ENABLE_SUSEREPO) || defined(ENABLE_RPMMD) || defined(ENABLE_RPMDB) || defined(ENABLE_RPMPKG))
 757 #include "pool_parserpmrichdep.h"
 758 #endif
 759 #include "solv_xfopen.h"
 760 #include "testcase.h"
 761
 762 /* for old ruby versions */
 763 #ifndef RARRAY_PTR
 764 #define RARRAY_PTR(ary) (RARRAY(ary)->ptr)
 765 #endif
 766 #ifndef RARRAY_LEN
 767 #define RARRAY_LEN(ary) (RARRAY(ary)->len)
 768 #endif
 769
 770 #define SOLVER_SOLUTION_ERASE                   -100
 771 #define SOLVER_SOLUTION_REPLACE                 -101
 772 #define SOLVER_SOLUTION_REPLACE_DOWNGRADE       -102
 773 #define SOLVER_SOLUTION_REPLACE_ARCHCHANGE      -103
 774 #define SOLVER_SOLUTION_REPLACE_VENDORCHANGE    -104
 775 #define SOLVER_SOLUTION_REPLACE_NAMECHANGE      -105
 776
 777 typedef void *AppObjectPtr;
 778 typedef Id DepId;
 779
 780 typedef struct {
 781   Pool *pool;
 782   Id id;
 783 } Dep;
 784
 785 typedef struct {
 786   Pool *pool;
 787   Id id;
 788 } XSolvable;
 789
 790 typedef struct {
 791   Solver *solv;
 792   Id id;
 793 } XRule;
 794
 795 typedef struct {
 796   Repo *repo;
 797   Id id;
 798 } XRepodata;
 799
 800 typedef struct {
 801   Pool *pool;
 802   Id id;
 803 } Pool_solvable_iterator;
 804
 805 typedef struct {
 806   Pool *pool;
 807   Id id;
 808 } Pool_repo_iterator;
 809
 810 typedef struct {
 811   Repo *repo;
 812   Id id;
 813 } Repo_solvable_iterator;
 814
 815 typedef struct {
 816   Pool *pool;
 817   int how;
 818   Id what;
 819 } Job;
 820
 821 typedef struct {
 822   Solver *solv;
 823   Id id;
 824 } Problem;
 825
 826 typedef struct {
 827   Solver *solv;
 828   Id problemid;
 829   Id id;
 830 } Solution;
 831
 832 typedef struct {
 833   Solver *solv;
 834   Id problemid;
 835   Id solutionid;
 836   Id id;
 837
 838   Id type;
 839   Id p;
 840   Id rp;
 841 } Solutionelement;
 842
 843 typedef struct {
 844   Solver *solv;
 845   Id rid;
 846   Id type;
 847   Id source;
 848   Id target;
 849   Id dep_id;
 850 } Ruleinfo;
 851
 852 typedef struct {
 853   Solver *solv;
 854   Id type;
 855   Id rid;
 856   Id from_id;
 857   Id dep_id;
 858   Id chosen_id;
 859   Queue choices;
 860   int level;
 861 } Alternative;
 862
 863 typedef struct {
 864   Transaction *transaction;
 865   int mode;
 866   Id type;
 867   int count;
 868   Id fromid;
 869   Id toid;
 870 } TransactionClass;
 871
 872 typedef struct {
 873   Pool *pool;
 874   Queue q;
 875   int flags;
 876 } Selection;
 877
 878 typedef struct {
 879   FILE *fp;
 880 } SolvFp;
 881
 882 typedef Dataiterator Datamatch;
 883
 884 typedef int disown_helper;
 885
 886 struct myappdata {
 887   void *appdata;
 888   int disowned;
 889 };
 890
 891
 892 %}
 893
 894 /**
 895  ** appdata helpers
 896  **/
 897
 898 #ifdef SWIGRUBY
 899
 900 %{
 901 SWIGINTERN void appdata_disown_helper(void *appdata) {
 902 }
 903 SWIGINTERN void appdata_clr_helper(void **appdatap) {
 904   *appdatap = 0;
 905 }
 906 SWIGINTERN void appdata_set_helper(void **appdatap, void *appdata) {
 907   *appdatap = appdata;
 908 }
 909 SWIGINTERN void *appdata_get_helper(void *appdata) {
 910   return appdata;
 911 }
 912 %}
 913
 914 #elif defined(SWIGTCL)
 915
 916 %{
 917 SWIGINTERN void appdata_disown_helper(void *appdata) {
 918 }
 919 SWIGINTERN void appdata_clr_helper(void **appdatap) {
 920   if (*appdatap)
 921     Tcl_DecrRefCount((Tcl_Obj *)(*appdatap));
 922   *appdatap = 0;
 923 }
 924 SWIGINTERN void appdata_set_helper(void **appdatap, void *appdata) {
 925   appdata_clr_helper(appdatap);
 926   *appdatap = appdata;
 927 }
 928 SWIGINTERN void *appdata_get_helper(void *appdata) {
 929   return appdata;
 930 }
 931 %}
 932
 933 #elif defined(SWIGPYTHON)
 934
 935 %{
 936 SWIGINTERN void appdata_disown_helper(void *appdata) {
 937   struct myappdata *myappdata = appdata;
 938   if (!myappdata || !myappdata->appdata || myappdata->disowned)
 939     return;
 940   myappdata->disowned = 1;
 941   Py_DECREF((PyObject *)myappdata->appdata);
 942 }
 943 SWIGINTERN void appdata_clr_helper(void **appdatap) {
 944   struct myappdata *myappdata = *(struct myappdata **)appdatap;
 945   if (myappdata && myappdata->appdata && !myappdata->disowned) {
 946     Py_DECREF((PyObject *)myappdata->appdata);
 947   }
 948   *appdatap = solv_free(myappdata);
 949 }
 950 SWIGINTERN void appdata_set_helper(void **appdatap, void *appdata) {
 951   appdata_clr_helper(appdatap);
 952   if (appdata) {
 953     struct myappdata *myappdata = *appdatap = solv_calloc(sizeof(struct myappdata), 1);
 954     myappdata->appdata = appdata;
 955   }
 956 }
 957 SWIGINTERN void *appdata_get_helper(void *appdata) {
 958   return appdata ? ((struct myappdata *)appdata)->appdata : 0;
 959 }
 960
 961 %}
 962
 963 #elif defined(SWIGPERL)
 964
 965 %{
 966 SWIGINTERN void appdata_disown_helper(void *appdata) {
 967   struct myappdata *myappdata = appdata;
 968   SV *rsv;
 969   if (!myappdata || !myappdata->appdata || myappdata->disowned)
 970     return;
 971   rsv = myappdata->appdata;
 972   if (!SvROK(rsv))
 973     return;
 974   myappdata->appdata = SvRV(rsv);
 975   myappdata->disowned = 1;
 976   SvREFCNT_dec(rsv);
 977 }
 978 SWIGINTERN void appdata_clr_helper(void **appdatap) {
 979   struct myappdata *myappdata = *(struct myappdata **)appdatap;
 980   if (myappdata && myappdata->appdata && !myappdata->disowned) {
 981     SvREFCNT_dec((SV *)myappdata->appdata);
 982   }
 983   *appdatap = solv_free(myappdata);
 984 }
 985 SWIGINTERN void appdata_set_helper(void **appdatap, void *appdata) {
 986   appdata_clr_helper(appdatap);
 987   if (appdata) {
 988     struct myappdata *myappdata = *appdatap = solv_calloc(sizeof(struct myappdata), 1);
 989     myappdata->appdata = appdata;
 990   }
 991 }
 992 SWIGINTERN void *appdata_get_helper(void *appdata) {
 993   struct myappdata *myappdata = appdata;
 994   if (!myappdata || !myappdata->appdata)
 995     return 0;
 996   return myappdata->disowned ? newRV_noinc((SV *)myappdata->appdata) : myappdata->appdata;
 997 }
 998
 999 %}
1000
1001 #else
1002 #warning appdata helpers not implemented for this language
1003 #endif
1004
1005
1006 /**
1007  ** the SWIG declarations defining the API
1008  **/
1009
1010 #ifdef SWIGRUBY
1011 %mixin Dataiterator "Enumerable";
1012 %mixin Pool_solvable_iterator "Enumerable";
1013 %mixin Pool_repo_iterator "Enumerable";
1014 %mixin Repo_solvable_iterator "Enumerable";
1015 #endif
1016
1017 typedef int Id;
1018
1019 %include "knownid.h"
1020
1021 /* from repodata.h */
1022 %constant Id SOLVID_META;
1023 %constant Id SOLVID_POS;
1024
1025 %constant int REL_EQ;
1026 %constant int REL_GT;
1027 %constant int REL_LT;
1028 %constant int REL_AND;
1029 %constant int REL_OR;
1030 %constant int REL_WITH;
1031 %constant int REL_NAMESPACE;
1032 %constant int REL_ARCH;
1033 %constant int REL_FILECONFLICT;
1034 %constant int REL_COND;
1035 %constant int REL_COMPAT;
1036 %constant int REL_KIND;
1037 %constant int REL_MULTIARCH;
1038 %constant int REL_ELSE;
1039 %constant int REL_ERROR;
1040 %constant int REL_WITHOUT;
1041 %constant int REL_UNLESS;
1042 %constant int REL_CONDA;
1043
1044 typedef struct {
1045   Pool* const pool;
1046   int const flags;
1047 } Selection;
1048
1049 typedef struct {
1050   Pool* const pool;
1051   Id const id;
1052 } Dep;
1053
1054 /* put before pool/repo so we can access the constructor */
1055 %nodefaultdtor Dataiterator;
1056 typedef struct {} Dataiterator;
1057
1058 typedef struct {
1059   Pool* const pool;
1060   Id const id;
1061 } XSolvable;
1062
1063 typedef struct {
1064   Solver* const solv;
1065   Id const type;
1066   Id const dep_id;
1067 } Ruleinfo;
1068
1069 typedef struct {
1070   Solver* const solv;
1071   Id const id;
1072 } XRule;
1073
1074 typedef struct {
1075   Repo* const repo;
1076   Id const id;
1077 } XRepodata;
1078
1079 typedef struct {} Pool_solvable_iterator;
1080 typedef struct {} Pool_repo_iterator;
1081 typedef struct {} Repo_solvable_iterator;
1082
1083 %nodefaultctor Datamatch;
1084 %nodefaultdtor Datamatch;
1085 typedef struct {
1086   Pool * const pool;
1087   Repo * const repo;
1088   Id const solvid;
1089 } Datamatch;
1090
1091 %nodefaultctor Datapos;
1092 typedef struct {
1093   Repo * const repo;
1094 } Datapos;
1095
1096 typedef struct {
1097   Pool * const pool;
1098   int how;
1099   Id what;
1100 } Job;
1101
1102 %nodefaultctor Pool;
1103 %nodefaultdtor Pool;
1104 typedef struct {
1105 } Pool;
1106
1107 %nodefaultctor Repo;
1108 %nodefaultdtor Repo;
1109 typedef struct {
1110   Pool * const pool;
1111   const char * const name;
1112   int priority;
1113   int subpriority;
1114   int const nsolvables;
1115 } Repo;
1116
1117 %nodefaultctor Solver;
1118 %nodefaultdtor Solver;
1119 typedef struct {
1120   Pool * const pool;
1121 } Solver;
1122
1123 typedef struct {
1124 } Chksum;
1125
1126 #ifdef ENABLE_PUBKEY
1127 typedef struct {
1128   Id const htype;
1129   unsigned int const created;
1130   unsigned int const expires;
1131   const char * const keyid;
1132 } Solvsig;
1133 #endif
1134
1135 %rename(xfopen) solvfp_xfopen;
1136 %rename(xfopen_fd) solvfp_xfopen_fd;
1137
1138 %nodefaultctor SolvFp;
1139 typedef struct {
1140 } SolvFp;
1141
1142 %newobject solvfp_xfopen;
1143 %newobject solvfp_xfopen_fd;
1144
1145 SolvFp *solvfp_xfopen(const char *fn, const char *mode = 0);
1146 SolvFp *solvfp_xfopen_fd(const char *fn, int fd, const char *mode = 0);
1147
1148 %{
1149   SWIGINTERN SolvFp *solvfp_xfopen_fd(const char *fn, int fd, const char *mode) {
1150     SolvFp *sfp;
1151     FILE *fp;
1152     fd = dup(fd);
1153     if (fd == -1)
1154       return 0;
1155     solv_setcloexec(fd, 1);
1156     fp = solv_xfopen_fd(fn, fd, mode);
1157     if (!fp) {
1158       close(fd);
1159       return 0;
1160     }
1161     sfp = solv_calloc(1, sizeof(SolvFp));
1162     sfp->fp = fp;
1163     return sfp;
1164   }
1165   SWIGINTERN SolvFp *solvfp_xfopen(const char *fn, const char *mode) {
1166     SolvFp *sfp;
1167     FILE *fp;
1168     fp = solv_xfopen(fn, mode);
1169     if (!fp)
1170       return 0;
1171     if (fileno(fp) != -1)
1172       solv_setcloexec(fileno(fp), 1);
1173     sfp = solv_calloc(1, sizeof(SolvFp));
1174     sfp->fp = fp;
1175     return sfp;
1176   }
1177 %}
1178
1179 typedef struct {
1180   Solver * const solv;
1181   Id const id;
1182 } Problem;
1183
1184 typedef struct {
1185   Solver * const solv;
1186   Id const problemid;
1187   Id const id;
1188 } Solution;
1189
1190 typedef struct {
1191   Solver *const solv;
1192   Id const problemid;
1193   Id const solutionid;
1194   Id const id;
1195   Id const type;
1196 } Solutionelement;
1197
1198 %nodefaultctor Alternative;
1199 typedef struct {
1200   Solver *const solv;
1201   Id const type;
1202   Id const rid;
1203   Id const from_id;
1204   Id const dep_id;
1205   Id const chosen_id;
1206   int level;
1207 } Alternative;
1208
1209 %nodefaultctor Transaction;
1210 %nodefaultdtor Transaction;
1211 typedef struct {
1212   Pool * const pool;
1213 } Transaction;
1214
1215 typedef struct {
1216   Transaction * const transaction;
1217   Id const type;
1218   Id const fromid;
1219   Id const toid;
1220   int const count;
1221 } TransactionClass;
1222
1223 %extend SolvFp {
1224   ~SolvFp() {
1225     if ($self->fp)
1226       fclose($self->fp);
1227     free($self);
1228   }
1229   int fileno() {
1230     return $self->fp ? fileno($self->fp) : -1;
1231   }
1232   int dup() {
1233     return $self->fp ? dup(fileno($self->fp)) : -1;
1234   }
1235   bool write(const unsigned char *str, size_t len) {
1236     return fwrite(str, len, 1, $self->fp) == 1;
1237   }
1238   bool flush() {
1239     if (!$self->fp)
1240       return 1;
1241     return fflush($self->fp) == 0;
1242   }
1243   bool close() {
1244     bool ret;
1245     if (!$self->fp)
1246       return 1;
1247     ret = fclose($self->fp) == 0;
1248     $self->fp = 0;
1249     return ret;
1250   }
1251   void cloexec(bool state) {
1252     if (!$self->fp || fileno($self->fp) == -1)
1253       return;
1254     solv_setcloexec(fileno($self->fp), state);
1255   }
1256 }
1257
1258 %extend Job {
1259   static const Id SOLVER_SOLVABLE = SOLVER_SOLVABLE;
1260   static const Id SOLVER_SOLVABLE_NAME = SOLVER_SOLVABLE_NAME;
1261   static const Id SOLVER_SOLVABLE_PROVIDES = SOLVER_SOLVABLE_PROVIDES;
1262   static const Id SOLVER_SOLVABLE_ONE_OF = SOLVER_SOLVABLE_ONE_OF;
1263   static const Id SOLVER_SOLVABLE_REPO = SOLVER_SOLVABLE_REPO;
1264   static const Id SOLVER_SOLVABLE_ALL = SOLVER_SOLVABLE_ALL;
1265   static const Id SOLVER_SELECTMASK = SOLVER_SELECTMASK;
1266   static const Id SOLVER_NOOP = SOLVER_NOOP;
1267   static const Id SOLVER_INSTALL = SOLVER_INSTALL;
1268   static const Id SOLVER_ERASE = SOLVER_ERASE;
1269   static const Id SOLVER_UPDATE = SOLVER_UPDATE;
1270   static const Id SOLVER_WEAKENDEPS = SOLVER_WEAKENDEPS;
1271   static const Id SOLVER_MULTIVERSION = SOLVER_MULTIVERSION;
1272   static const Id SOLVER_LOCK = SOLVER_LOCK;
1273   static const Id SOLVER_DISTUPGRADE = SOLVER_DISTUPGRADE;
1274   static const Id SOLVER_VERIFY = SOLVER_VERIFY;
1275   static const Id SOLVER_DROP_ORPHANED = SOLVER_DROP_ORPHANED;
1276   static const Id SOLVER_USERINSTALLED = SOLVER_USERINSTALLED;
1277   static const Id SOLVER_ALLOWUNINSTALL = SOLVER_ALLOWUNINSTALL;
1278   static const Id SOLVER_FAVOR = SOLVER_FAVOR;
1279   static const Id SOLVER_DISFAVOR = SOLVER_DISFAVOR;
1280   static const Id SOLVER_JOBMASK = SOLVER_JOBMASK;
1281   static const Id SOLVER_WEAK = SOLVER_WEAK;
1282   static const Id SOLVER_ESSENTIAL = SOLVER_ESSENTIAL;
1283   static const Id SOLVER_CLEANDEPS = SOLVER_CLEANDEPS;
1284   static const Id SOLVER_FORCEBEST = SOLVER_FORCEBEST;
1285   static const Id SOLVER_TARGETED = SOLVER_TARGETED;
1286   static const Id SOLVER_NOTBYUSER = SOLVER_NOTBYUSER;
1287   static const Id SOLVER_SETEV = SOLVER_SETEV;
1288   static const Id SOLVER_SETEVR = SOLVER_SETEVR;
1289   static const Id SOLVER_SETARCH = SOLVER_SETARCH;
1290   static const Id SOLVER_SETVENDOR = SOLVER_SETVENDOR;
1291   static const Id SOLVER_SETREPO = SOLVER_SETREPO;
1292   static const Id SOLVER_SETNAME = SOLVER_SETNAME;
1293   static const Id SOLVER_NOAUTOSET = SOLVER_NOAUTOSET;
1294   static const Id SOLVER_SETMASK = SOLVER_SETMASK;
1295
1296   Job(Pool *pool, int how, Id what) {
1297     Job *job = solv_calloc(1, sizeof(*job));
1298     job->pool = pool;
1299     job->how = how;
1300     job->what = what;
1301     return job;
1302   }
1303
1304   %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1305   %newobject solvables;
1306   Queue solvables() {
1307     Queue q;
1308     queue_init(&q);
1309     pool_job2solvables($self->pool, &q, $self->how, $self->what);
1310     return q;
1311   }
1312 #ifdef SWIGRUBY
1313   %rename("isemptyupdate?") isemptyupdate;
1314 #endif
1315   bool isemptyupdate() {
1316     return pool_isemptyupdatejob($self->pool, $self->how, $self->what);
1317   }
1318
1319 #if defined(SWIGTCL)
1320   %rename("==") __eq__;
1321 #endif
1322   bool __eq__(Job *j) {
1323     return $self->pool == j->pool && $self->how == j->how && $self->what == j->what;
1324   }
1325 #if defined(SWIGTCL)
1326   %rename("!=") __ne__;
1327 #endif
1328   bool __ne__(Job *j) {
1329     return !Job___eq__($self, j);
1330   }
1331 #if defined(SWIGPERL) || defined(SWIGTCL)
1332   %rename("str") __str__;
1333 #endif
1334   const char *__str__() {
1335     return pool_job2str($self->pool, $self->how, $self->what, 0);
1336   }
1337 #if defined(SWIGPERL) || defined(SWIGTCL)
1338   %rename("repr") __repr__;
1339 #endif
1340   const char *__repr__() {
1341     const char *str = pool_job2str($self->pool, $self->how, $self->what, ~0);
1342     return pool_tmpjoin($self->pool, "<Job ", str, ">");
1343   }
1344 }
1345
1346 %extend Selection {
1347   static const Id SELECTION_NAME = SELECTION_NAME;
1348   static const Id SELECTION_PROVIDES = SELECTION_PROVIDES;
1349   static const Id SELECTION_FILELIST = SELECTION_FILELIST;
1350   static const Id SELECTION_CANON = SELECTION_CANON;
1351   static const Id SELECTION_DOTARCH = SELECTION_DOTARCH;
1352   static const Id SELECTION_REL = SELECTION_REL;
1353   static const Id SELECTION_INSTALLED_ONLY = SELECTION_INSTALLED_ONLY;
1354   static const Id SELECTION_GLOB = SELECTION_GLOB;
1355   static const Id SELECTION_FLAT = SELECTION_FLAT;
1356   static const Id SELECTION_NOCASE = SELECTION_NOCASE;
1357   static const Id SELECTION_SKIP_KIND = SELECTION_SKIP_KIND;
1358   static const Id SELECTION_MATCH_DEPSTR = SELECTION_MATCH_DEPSTR;
1359   static const Id SELECTION_SOURCE_ONLY = SELECTION_SOURCE_ONLY;
1360   static const Id SELECTION_WITH_SOURCE = SELECTION_WITH_SOURCE;
1361   static const Id SELECTION_WITH_DISABLED = SELECTION_WITH_DISABLED;
1362   static const Id SELECTION_WITH_BADARCH = SELECTION_WITH_BADARCH;
1363   static const Id SELECTION_WITH_ALL = SELECTION_WITH_ALL;
1364   static const Id SELECTION_ADD = SELECTION_ADD;
1365   static const Id SELECTION_SUBTRACT = SELECTION_SUBTRACT;
1366   static const Id SELECTION_FILTER = SELECTION_FILTER;
1367   static const Id SELECTION_FILTER_KEEP_IFEMPTY = SELECTION_FILTER_KEEP_IFEMPTY;
1368   static const Id SELECTION_FILTER_SWAPPED = SELECTION_FILTER_SWAPPED;
1369
1370   Selection(Pool *pool) {
1371     Selection *s;
1372     s = solv_calloc(1, sizeof(*s));
1373     s->pool = pool;
1374     return s;
1375   }
1376
1377   ~Selection() {
1378     queue_free(&$self->q);
1379     solv_free($self);
1380   }
1381 #ifdef SWIGRUBY
1382   %rename("isempty?") isempty;
1383 #endif
1384   bool isempty() {
1385     return $self->q.count == 0;
1386   }
1387   %newobject clone;
1388   Selection *clone(int flags = 0) {
1389     Selection *s = new_Selection($self->pool);
1390     queue_init_clone(&s->q, &$self->q);
1391     s->flags = $self->flags;
1392     return s;
1393   }
1394 returnself(filter)
1395   void filter(Selection *lsel) {
1396     if ($self->pool != lsel->pool)
1397       queue_empty(&$self->q);
1398     else
1399       selection_filter($self->pool, &$self->q, &lsel->q);
1400   }
1401 returnself(add)
1402   void add(Selection *lsel) {
1403     if ($self->pool == lsel->pool)
1404       {
1405         selection_add($self->pool, &$self->q, &lsel->q);
1406         $self->flags |= lsel->flags;
1407       }
1408   }
1409 returnself(add_raw)
1410   void add_raw(Id how, Id what) {
1411     queue_push2(&$self->q, how, what);
1412   }
1413 returnself(subtract)
1414   void subtract(Selection *lsel) {
1415     if ($self->pool == lsel->pool)
1416       selection_subtract($self->pool, &$self->q, &lsel->q);
1417   }
1418
1419 returnself(select)
1420   void select(const char *name, int flags) {
1421     if ((flags & SELECTION_MODEBITS) == 0)
1422       flags |= SELECTION_FILTER | SELECTION_WITH_ALL;
1423     $self->flags = selection_make($self->pool, &$self->q, name, flags);
1424   }
1425 returnself(matchdeps)
1426   void matchdeps(const char *name, int flags, Id keyname, Id marker = -1) {
1427     if ((flags & SELECTION_MODEBITS) == 0)
1428       flags |= SELECTION_FILTER | SELECTION_WITH_ALL;
1429     $self->flags = selection_make_matchdeps($self->pool, &$self->q, name, flags, keyname, marker);
1430   }
1431 returnself(matchdepid)
1432   void matchdepid(DepId dep, int flags, Id keyname, Id marker = -1) {
1433     if ((flags & SELECTION_MODEBITS) == 0)
1434       flags |= SELECTION_FILTER | SELECTION_WITH_ALL;
1435     $self->flags = selection_make_matchdepid($self->pool, &$self->q, dep, flags, keyname, marker);
1436   }
1437 returnself(matchsolvable)
1438   void matchsolvable(XSolvable *solvable, int flags, Id keyname, Id marker = -1) {
1439     if ((flags & SELECTION_MODEBITS) == 0)
1440       flags |= SELECTION_FILTER | SELECTION_WITH_ALL;
1441     $self->flags = selection_make_matchsolvable($self->pool, &$self->q, solvable->id, flags, keyname, marker);
1442   }
1443
1444   %typemap(out) Queue jobs Queue2Array(Job *, 2, new_Job(arg1->pool, id, idp[1]));
1445   %newobject jobs;
1446   Queue jobs(int flags) {
1447     Queue q;
1448     int i;
1449     queue_init_clone(&q, &$self->q);
1450     for (i = 0; i < q.count; i += 2)
1451       q.elements[i] |= flags;
1452     return q;
1453   }
1454
1455   %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1456   %newobject solvables;
1457   Queue solvables() {
1458     Queue q;
1459     queue_init(&q);
1460     selection_solvables($self->pool, &$self->q, &q);
1461     return q;
1462   }
1463
1464 #if defined(SWIGPERL) || defined(SWIGTCL)
1465   %rename("str") __str__;
1466 #endif
1467   const char *__str__() {
1468     return pool_selection2str($self->pool, &$self->q, 0);
1469   }
1470 #if defined(SWIGPERL) || defined(SWIGTCL)
1471   %rename("repr") __repr__;
1472 #endif
1473   const char *__repr__() {
1474     const char *str = pool_selection2str($self->pool, &$self->q, ~0);
1475     return pool_tmpjoin($self->pool, "<Selection ", str, ">");
1476   }
1477 }
1478
1479 %extend Chksum {
1480   Chksum(Id type) {
1481     return solv_chksum_create(type);
1482   }
1483   Chksum(Id type, const char *hex) {
1484     unsigned char buf[64];
1485     int l = solv_chksum_len(type);
1486     if (!l)
1487       return 0;
1488     if (solv_hex2bin(&hex, buf, sizeof(buf)) != l || hex[0])
1489       return 0;
1490     return solv_chksum_create_from_bin(type, buf);
1491   }
1492   %newobject from_bin;
1493   static Chksum *from_bin(Id type, const unsigned char *str, size_t len) {
1494     return len == solv_chksum_len(type) ? solv_chksum_create_from_bin(type, str) : 0;
1495   }
1496 #if defined(SWIGPERL)
1497   %perlcode {
1498     undef *solv::Chksum::from_bin;
1499     *solv::Chksum::from_bin = sub {
1500       my $pkg = shift;
1501       my $self = solvc::Chksum_from_bin(@_);
1502       bless $self, $pkg if defined $self;
1503     };
1504   }
1505 #endif
1506   ~Chksum() {
1507     solv_chksum_free($self, 0);
1508   }
1509   Id const type;
1510   %{
1511   SWIGINTERN Id Chksum_type_get(Chksum *chk) {
1512     return solv_chksum_get_type(chk);
1513   }
1514   %}
1515   void add(const unsigned char *str, size_t len) {
1516     solv_chksum_add($self, str, (int)len);
1517   }
1518   void add_fp(FILE *fp) {
1519     char buf[4096];
1520     int l;
1521     while ((l = fread(buf, 1, sizeof(buf), fp)) > 0)
1522       solv_chksum_add($self, buf, l);
1523     rewind(fp);         /* convenience */
1524   }
1525   void add_fd(int fd) {
1526     char buf[4096];
1527     int l;
1528     while ((l = read(fd, buf, sizeof(buf))) > 0)
1529       solv_chksum_add($self, buf, l);
1530     lseek(fd, 0, 0);    /* convenience */
1531   }
1532   void add_stat(const char *filename) {
1533     struct stat stb;
1534     if (stat(filename, &stb))
1535       memset(&stb, 0, sizeof(stb));
1536     solv_chksum_add($self, &stb.st_dev, sizeof(stb.st_dev));
1537     solv_chksum_add($self, &stb.st_ino, sizeof(stb.st_ino));
1538     solv_chksum_add($self, &stb.st_size, sizeof(stb.st_size));
1539     solv_chksum_add($self, &stb.st_mtime, sizeof(stb.st_mtime));
1540   }
1541   void add_fstat(int fd) {
1542     struct stat stb;
1543     if (fstat(fd, &stb))
1544       memset(&stb, 0, sizeof(stb));
1545     solv_chksum_add($self, &stb.st_dev, sizeof(stb.st_dev));
1546     solv_chksum_add($self, &stb.st_ino, sizeof(stb.st_ino));
1547     solv_chksum_add($self, &stb.st_size, sizeof(stb.st_size));
1548     solv_chksum_add($self, &stb.st_mtime, sizeof(stb.st_mtime));
1549   }
1550   BinaryBlob raw() {
1551     BinaryBlob bl;
1552     int l;
1553     const unsigned char *b;
1554     b = solv_chksum_get($self, &l);
1555     bl.data = b;
1556     bl.len = l;
1557     return bl;
1558   }
1559   %newobject hex;
1560   char *hex() {
1561     int l;
1562     const unsigned char *b;
1563     char *ret;
1564
1565     b = solv_chksum_get($self, &l);
1566     ret = solv_malloc(2 * l + 1);
1567     solv_bin2hex(b, l, ret);
1568     return ret;
1569   }
1570   const char *typestr() {
1571     return solv_chksum_type2str(solv_chksum_get_type($self));
1572   }
1573
1574 #if defined(SWIGTCL)
1575   %rename("==") __eq__;
1576 #endif
1577   bool __eq__(Chksum *chk) {
1578     return solv_chksum_cmp($self, chk);
1579   }
1580 #if defined(SWIGTCL)
1581   %rename("!=") __ne__;
1582 #endif
1583   bool __ne__(Chksum *chk) {
1584     return !solv_chksum_cmp($self, chk);
1585   }
1586 #if defined(SWIGRUBY)
1587   %rename("to_s") __str__;
1588 #endif
1589 #if defined(SWIGPERL) || defined(SWIGTCL)
1590   %rename("str") __str__;
1591 #endif
1592   %newobject __str__;
1593   const char *__str__() {
1594     const char *str;
1595     const char *h = 0;
1596     if (solv_chksum_isfinished($self))
1597       h = Chksum_hex($self);
1598     str = solv_dupjoin(solv_chksum_type2str(solv_chksum_get_type($self)), ":", h ? h : "unfinished");
1599     solv_free((void *)h);
1600     return str;
1601   }
1602 #if defined(SWIGPERL) || defined(SWIGTCL)
1603   %rename("repr") __repr__;
1604 #endif
1605   %newobject __repr__;
1606   const char *__repr__() {
1607     const char *h = Chksum___str__($self);
1608     const char *str = solv_dupjoin("<Chksum ", h, ">");
1609     solv_free((void *)h);
1610     return str;
1611   }
1612 }
1613
1614 %extend Pool {
1615   static const int POOL_FLAG_PROMOTEEPOCH = POOL_FLAG_PROMOTEEPOCH;
1616   static const int POOL_FLAG_FORBIDSELFCONFLICTS = POOL_FLAG_FORBIDSELFCONFLICTS;
1617   static const int POOL_FLAG_OBSOLETEUSESPROVIDES = POOL_FLAG_OBSOLETEUSESPROVIDES;
1618   static const int POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES = POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES;
1619   static const int POOL_FLAG_OBSOLETEUSESCOLORS = POOL_FLAG_OBSOLETEUSESCOLORS;
1620   static const int POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS = POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS;
1621   static const int POOL_FLAG_NOINSTALLEDOBSOLETES = POOL_FLAG_NOINSTALLEDOBSOLETES;
1622   static const int POOL_FLAG_HAVEDISTEPOCH = POOL_FLAG_HAVEDISTEPOCH;
1623   static const int POOL_FLAG_NOOBSOLETESMULTIVERSION = POOL_FLAG_NOOBSOLETESMULTIVERSION;
1624   static const int DISTTYPE_RPM = DISTTYPE_RPM;
1625   static const int DISTTYPE_DEB = DISTTYPE_DEB;
1626   static const int DISTTYPE_ARCH = DISTTYPE_ARCH;
1627   static const int DISTTYPE_HAIKU = DISTTYPE_HAIKU;
1628
1629   Pool() {
1630     Pool *pool = pool_create();
1631     return pool;
1632   }
1633   int setdisttype(int disttype) {
1634     return pool_setdisttype($self, disttype);
1635   }
1636   void set_debuglevel(int level) {
1637     pool_setdebuglevel($self, level);
1638   }
1639   int set_flag(int flag, int value) {
1640     return pool_set_flag($self, flag, value);
1641   }
1642   int get_flag(int flag) {
1643     return pool_get_flag($self, flag);
1644   }
1645   void set_rootdir(const char *rootdir) {
1646     pool_set_rootdir($self, rootdir);
1647   }
1648   const char *get_rootdir(int flag) {
1649     return pool_get_rootdir($self);
1650   }
1651 #if defined(SWIGPYTHON)
1652   %{
1653   SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
1654     XRepodata *xd = new_XRepodata(data->repo, data->repodataid);
1655     PyObject *args = Py_BuildValue("(O)", SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_POINTER_OWN | 0));
1656     PyObject *result = PyEval_CallObject((PyObject *)d, args);
1657     int ecode = 0;
1658     int vresult = 0;
1659     Py_DECREF(args);
1660     if (!result)
1661       return 0; /* exception */
1662     ecode = SWIG_AsVal_int(result, &vresult);
1663     Py_DECREF(result);
1664     return SWIG_IsOK(ecode) ? vresult : 0;
1665   }
1666   %}
1667   void clr_loadcallback() {
1668     if ($self->loadcallback == loadcallback) {
1669       PyObject *obj = $self->loadcallbackdata;
1670       Py_DECREF(obj);
1671       pool_setloadcallback($self, 0, 0);
1672     }
1673   }
1674   void set_loadcallback(PyObject *callable) {
1675     Pool_clr_loadcallback($self);
1676     if (callable) {
1677       Py_INCREF(callable);
1678       pool_setloadcallback($self, loadcallback, callable);
1679     }
1680   }
1681 #elif defined(SWIGPERL)
1682 %{
1683   SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
1684     int count;
1685     int ret = 0;
1686     dSP;
1687     XRepodata *xd = new_XRepodata(data->repo, data->repodataid);
1688
1689     ENTER;
1690     SAVETMPS;
1691     PUSHMARK(SP);
1692     XPUSHs(SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_OWNER | SWIG_SHADOW));
1693     PUTBACK;
1694     count = perl_call_sv((SV *)d, G_EVAL|G_SCALAR);
1695     SPAGAIN;
1696     if (count)
1697       ret = POPi;
1698     PUTBACK;
1699     FREETMPS;
1700     LEAVE;
1701     return ret;
1702   }
1703 %}
1704   void clr_loadcallback() {
1705     if ($self->loadcallback == loadcallback) {
1706       SvREFCNT_dec($self->loadcallbackdata);
1707       pool_setloadcallback($self, 0, 0);
1708     }
1709   }
1710   void set_loadcallback(SV *callable) {
1711     Pool_clr_loadcallback($self);
1712     if (callable) {
1713       SvREFCNT_inc(callable);
1714       pool_setloadcallback($self, loadcallback, callable);
1715     }
1716   }
1717 #elif defined(SWIGRUBY)
1718 %{
1719   SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
1720     XRepodata *xd = new_XRepodata(data->repo, data->repodataid);
1721     VALUE callable = (VALUE)d;
1722     VALUE rd = SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_POINTER_OWN | 0);
1723     VALUE res = rb_funcall(callable, rb_intern("call"), 1, rd);
1724     return res == Qtrue;
1725   }
1726   SWIGINTERN void mark_Pool(void *ptr) {
1727     Pool *pool = ptr;
1728     if (pool->loadcallback == loadcallback && pool->loadcallbackdata) {
1729       VALUE callable = (VALUE)pool->loadcallbackdata;
1730       rb_gc_mark(callable);
1731     }
1732   }
1733 %}
1734   void clr_loadcallback() {
1735     pool_setloadcallback($self, 0, 0);
1736   }
1737   %typemap(in, numinputs=0) VALUE callable {
1738     $1 = rb_block_given_p() ? rb_block_proc() : 0;
1739   }
1740   void set_loadcallback(VALUE callable) {
1741     pool_setloadcallback($self, callable ? loadcallback : 0, (void *)callable);
1742   }
1743 #elif defined(SWIGTCL)
1744   %{
1745   typedef struct {
1746     Tcl_Interp *interp;
1747     Tcl_Obj *obj;
1748   } tcl_callback_t;
1749   SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
1750     tcl_callback_t *callback_var = (tcl_callback_t *)d;
1751     Tcl_Interp *interp = callback_var->interp;
1752     XRepodata *xd = new_XRepodata(data->repo, data->repodataid);
1753     int result, ecode = 0, vresult = 0;
1754     Tcl_Obj *objvx[2];
1755     objvx[0] = callback_var->obj;
1756     objvx[1] = SWIG_NewInstanceObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, 0);
1757     Tcl_IncrRefCount(objvx[1]);
1758     result = Tcl_EvalObjv(interp, sizeof(objvx)/sizeof(*objvx), objvx, TCL_EVAL_GLOBAL);
1759     Tcl_DecrRefCount(objvx[1]);
1760     if (result != TCL_OK)
1761       return 0; /* exception */
1762     ecode = SWIG_AsVal_int(interp, Tcl_GetObjResult(interp), &vresult);
1763     return SWIG_IsOK(ecode) ? vresult : 0;
1764   }
1765   %}
1766   void clr_loadcallback() {
1767     if ($self->loadcallback == loadcallback) {
1768       tcl_callback_t *callback_var = $self->loadcallbackdata;
1769       Tcl_DecrRefCount(callback_var->obj);
1770       solv_free(callback_var);
1771       pool_setloadcallback($self, 0, 0);
1772     }
1773   }
1774   void set_loadcallback(Tcl_Obj *callable, Tcl_Interp *interp) {
1775     Pool_clr_loadcallback($self);
1776     if (callable) {
1777       tcl_callback_t *callback_var = solv_malloc(sizeof(tcl_callback_t));
1778       Tcl_IncrRefCount(callable);
1779       callback_var->interp = interp;
1780       callback_var->obj = callable;
1781       pool_setloadcallback($self, loadcallback, callback_var);
1782     }
1783   }
1784 #else
1785 #warning loadcallback not implemented for this language
1786 #endif
1787
1788   ~Pool() {
1789     Pool *pool = $self;
1790     Id repoid;
1791     Repo *repo;
1792     FOR_REPOS(repoid, repo)
1793       appdata_clr_helper(&repo->appdata);
1794     Pool_clr_loadcallback(pool);
1795     appdata_clr_helper(&pool->appdata);
1796     pool_free(pool);
1797   }
1798   disown_helper free() {
1799     Pool *pool = $self;
1800     Id repoid;
1801     Repo *repo;
1802     FOR_REPOS(repoid, repo)
1803       appdata_clr_helper(&repo->appdata);
1804     Pool_clr_loadcallback(pool);
1805     appdata_clr_helper(&pool->appdata);
1806     pool_free(pool);
1807     return 0;
1808   }
1809   disown_helper disown() {
1810     return 0;
1811   }
1812   AppObjectPtr appdata;
1813   %{
1814   SWIGINTERN void Pool_appdata_set(Pool *pool, AppObjectPtr appdata) {
1815     appdata_set_helper(&pool->appdata, appdata);
1816   }
1817   SWIGINTERN AppObjectPtr Pool_appdata_get(Pool *pool) {
1818     return appdata_get_helper(pool->appdata);
1819   }
1820   %}
1821   void appdata_disown() {
1822     appdata_disown_helper($self->appdata);
1823   }
1824
1825   Id str2id(const char *str, bool create=1) {
1826     return pool_str2id($self, str, create);
1827   }
1828   %newobject Dep;
1829   Dep *Dep(const char *str, bool create=1) {
1830     Id id = pool_str2id($self, str, create);
1831     return new_Dep($self, id);
1832   }
1833 #if defined(ENABLE_COMPLEX_DEPS) && (defined(ENABLE_SUSEREPO) || defined(ENABLE_RPMMD) || defined(ENABLE_RPMDB) || defined(ENABLE_RPMPKG))
1834   %newobject Dep;
1835   Dep *parserpmrichdep(const char *str) {
1836     Id id = pool_parserpmrichdep($self, str);
1837     return new_Dep($self, id);
1838   }
1839 #endif
1840   const char *id2str(Id id) {
1841     return pool_id2str($self, id);
1842   }
1843   const char *dep2str(Id id) {
1844     return pool_dep2str($self, id);
1845   }
1846   Id rel2id(Id name, Id evr, int flags, bool create=1) {
1847     return pool_rel2id($self, name, evr, flags, create);
1848   }
1849   Id id2langid(Id id, const char *lang, bool create=1) {
1850     return pool_id2langid($self, id, lang, create);
1851   }
1852   void setarch(const char *arch = 0) {
1853     struct utsname un;
1854     if (!arch) {
1855       if (uname(&un)) {
1856         perror("uname");
1857         return;
1858       }
1859       arch = un.machine;
1860     }
1861     pool_setarch($self, arch);
1862   }
1863   Repo *add_repo(const char *name) {
1864     return repo_create($self, name);
1865   }
1866   const char *lookup_str(Id entry, Id keyname) {
1867     return pool_lookup_str($self, entry, keyname);
1868   }
1869   Id lookup_id(Id entry, Id keyname) {
1870     return pool_lookup_id($self, entry, keyname);
1871   }
1872   unsigned long long lookup_num(Id entry, Id keyname, unsigned long long notfound = 0) {
1873     return pool_lookup_num($self, entry, keyname, notfound);
1874   }
1875   bool lookup_void(Id entry, Id keyname) {
1876     return pool_lookup_void($self, entry, keyname);
1877   }
1878   %newobject lookup_checksum;
1879   Chksum *lookup_checksum(Id entry, Id keyname) {
1880     Id type = 0;
1881     const unsigned char *b = pool_lookup_bin_checksum($self, entry, keyname, &type);
1882     return solv_chksum_create_from_bin(type, b);
1883   }
1884
1885   %newobject Dataiterator;
1886   Dataiterator *Dataiterator(Id key, const char *match = 0, int flags = 0) {
1887     return new_Dataiterator($self, 0, 0, key, match, flags);
1888   }
1889   %newobject Dataiterator_solvid;
1890   Dataiterator *Dataiterator_solvid(Id p, Id key, const char *match = 0, int flags = 0) {
1891     return new_Dataiterator($self, 0, p, key, match, flags);
1892   }
1893   const char *solvid2str(Id solvid) {
1894     return pool_solvid2str($self, solvid);
1895   }
1896   void addfileprovides() {
1897     pool_addfileprovides($self);
1898   }
1899   Queue addfileprovides_queue() {
1900     Queue r;
1901     queue_init(&r);
1902     pool_addfileprovides_queue($self, &r, 0);
1903     return r;
1904   }
1905   void createwhatprovides() {
1906     pool_createwhatprovides($self);
1907   }
1908
1909   %newobject id2solvable;
1910   XSolvable *id2solvable(Id id) {
1911     return new_XSolvable($self, id);
1912   }
1913   %newobject solvables;
1914   Pool_solvable_iterator * const solvables;
1915   %{
1916   SWIGINTERN Pool_solvable_iterator * Pool_solvables_get(Pool *pool) {
1917     return new_Pool_solvable_iterator(pool);
1918   }
1919   %}
1920   %newobject solvables_iter;
1921   Pool_solvable_iterator * solvables_iter() {
1922     return new_Pool_solvable_iterator($self);
1923   }
1924
1925   Repo *id2repo(Id id) {
1926     if (id < 1 || id >= $self->nrepos)
1927       return 0;
1928     return pool_id2repo($self, id);
1929   }
1930
1931   %newobject repos;
1932   Pool_repo_iterator * const repos;
1933   %{
1934   SWIGINTERN Pool_repo_iterator * Pool_repos_get(Pool *pool) {
1935     return new_Pool_repo_iterator(pool);
1936   }
1937   %}
1938   %newobject repos_iter;
1939   Pool_repo_iterator * repos_iter() {
1940     return new_Pool_repo_iterator($self);
1941   }
1942
1943   Repo *installed;
1944   const char * const errstr;
1945   %{
1946   SWIGINTERN void Pool_installed_set(Pool *pool, Repo *installed) {
1947     pool_set_installed(pool, installed);
1948   }
1949   SWIGINTERN Repo *Pool_installed_get(Pool *pool) {
1950     return pool->installed;
1951   }
1952   SWIGINTERN const char *Pool_errstr_get(Pool *pool) {
1953     return pool_errstr(pool);
1954   }
1955   %}
1956
1957   Queue matchprovidingids(const char *match, int flags) {
1958     Pool *pool = $self;
1959     Queue q;
1960     Id id;
1961     queue_init(&q);
1962     if (!flags) {
1963       for (id = 1; id < pool->ss.nstrings; id++)
1964         if (pool->whatprovides[id])
1965           queue_push(&q, id);
1966     } else {
1967       Datamatcher ma;
1968       if (!datamatcher_init(&ma, match, flags)) {
1969         for (id = 1; id < pool->ss.nstrings; id++)
1970           if (pool->whatprovides[id] && datamatcher_match(&ma, pool_id2str(pool, id)))
1971             queue_push(&q, id);
1972         datamatcher_free(&ma);
1973       }
1974     }
1975     return q;
1976   }
1977
1978   %newobject Job;
1979   Job *Job(int how, Id what) {
1980     return new_Job($self, how, what);
1981   }
1982
1983   %typemap(out) Queue whatprovides Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
1984   %newobject whatprovides;
1985   Queue whatprovides(DepId dep) {
1986     Pool *pool = $self;
1987     Queue q;
1988     Id p, pp;
1989     queue_init(&q);
1990     FOR_PROVIDES(p, pp, dep)
1991       queue_push(&q, p);
1992     return q;
1993   }
1994   %typemap(out) Queue best_solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
1995   %newobject best_solvables;
1996   Queue best_solvables(Queue solvables, int flags=0) {
1997     Queue q;
1998     queue_init_clone(&q, &solvables);
1999     pool_best_solvables($self, &q, flags);
2000     return q;
2001   }
2002
2003   Id towhatprovides(Queue q) {
2004     return pool_queuetowhatprovides($self, &q);
2005   }
2006
2007   void set_namespaceproviders(DepId ns, DepId evr, bool value=1) {
2008     Id dep = pool_rel2id($self, ns, evr, REL_NAMESPACE, 1);
2009     pool_set_whatprovides($self, dep, value ? 2 : 1);
2010   }
2011
2012   void flush_namespaceproviders(DepId ns, DepId evr) {
2013     pool_flush_namespaceproviders($self, ns, evr);
2014   }
2015
2016   %typemap(out) Queue whatcontainsdep Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
2017   %newobject whatcontainsdep;
2018   Queue whatcontainsdep(Id keyname, DepId dep, Id marker = -1) {
2019     Queue q;
2020     queue_init(&q);
2021     pool_whatcontainsdep($self, keyname, dep, &q, marker);
2022     return q;
2023   }
2024
2025   %typemap(out) Queue whatmatchesdep Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
2026   %newobject whatmatchesdep;
2027   Queue whatmatchesdep(Id keyname, DepId dep, Id marker = -1) {
2028     Queue q;
2029     queue_init(&q);
2030     pool_whatmatchesdep($self, keyname, dep, &q, marker);
2031     return q;
2032   }
2033
2034   %typemap(out) Queue whatmatchessolvable Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
2035   %newobject whatmatchessolvable;
2036   Queue whatmatchessolvable(Id keyname, XSolvable *pool_solvable, Id marker = -1) {
2037     Queue q;
2038     queue_init(&q);
2039     pool_whatmatchessolvable($self, keyname, pool_solvable->id, &q, marker);
2040     return q;
2041   }
2042
2043 #ifdef SWIGRUBY
2044   %rename("isknownarch?") isknownarch;
2045 #endif
2046   bool isknownarch(DepId id) {
2047     Pool *pool = $self;
2048     if (!id || id == ID_EMPTY)
2049       return 0;
2050     if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
2051       return 1;
2052     if (pool->id2arch && pool_arch2score(pool, id) == 0)
2053       return 0;
2054     return 1;
2055   }
2056
2057   %newobject Solver;
2058   Solver *Solver() {
2059     return solver_create($self);
2060   }
2061
2062   %newobject Selection;
2063   Selection *Selection() {
2064     return new_Selection($self);
2065   }
2066   %newobject Selection_all;
2067   Selection *Selection_all(int setflags=0) {
2068     Selection *sel = new_Selection($self);
2069     queue_push2(&sel->q, SOLVER_SOLVABLE_ALL | setflags, 0);
2070     return sel;
2071   }
2072   %newobject select;
2073   Selection *select(const char *name, int flags) {
2074     Selection *sel = new_Selection($self);
2075     sel->flags = selection_make($self, &sel->q, name, flags);
2076     return sel;
2077   }
2078
2079   %newobject matchdeps;
2080   Selection *matchdeps(const char *name, int flags, Id keyname, Id marker = -1) {
2081     Selection *sel = new_Selection($self);
2082     sel->flags = selection_make_matchdeps($self, &sel->q, name, flags, keyname, marker);
2083     return sel;
2084   }
2085
2086   %newobject matchdepid;
2087   Selection *matchdepid(DepId dep, int flags, Id keyname, Id marker = -1) {
2088     Selection *sel = new_Selection($self);
2089     sel->flags = selection_make_matchdepid($self, &sel->q, dep, flags, keyname, marker);
2090     return sel;
2091   }
2092
2093   %newobject matchsolvable;
2094   Selection *matchsolvable(XSolvable *solvable, int flags, Id keyname, Id marker = -1) {
2095     Selection *sel = new_Selection($self);
2096     sel->flags = selection_make_matchsolvable($self, &sel->q, solvable->id, flags, keyname, marker);
2097     return sel;
2098   }
2099
2100   Queue get_considered_list() {
2101     Queue q;
2102     queue_init(&q);
2103     int i;
2104     for (i = 2; i < $self->nsolvables; i++) {
2105       if ($self->solvables[i].repo && (!$self->considered || MAPTST($self->considered, i)))
2106         queue_push(&q, i);
2107     }
2108     return q;
2109   }
2110
2111   Queue get_disabled_list() {
2112     Queue q;
2113     queue_init(&q);
2114     int i;
2115     for (i = 2; i < $self->nsolvables; i++) {
2116       if ($self->solvables[i].repo && ($self->considered && !MAPTST($self->considered, i)))
2117         queue_push(&q, i);
2118     }
2119     return q;
2120   }
2121
2122   void set_considered_list(Queue q) {
2123     int i;
2124     Id p;
2125     if (!$self->considered) {
2126       $self->considered = solv_calloc(1, sizeof(Map));
2127       map_init($self->considered, $self->nsolvables);
2128     }
2129     map_empty($self->considered);
2130     MAPSET($self->considered, 1);
2131     for (i = 0; i < q.count; i++) {
2132       p = q.elements[i];
2133       if (p > 0 && p < $self->nsolvables)
2134         MAPSET($self->considered, p);
2135     }
2136   }
2137
2138   void set_disabled_list(Queue q) {
2139     int i;
2140     Id p;
2141     if (!q.count) {
2142       if ($self->considered) {
2143         map_free($self->considered);
2144         $self->considered = solv_free($self->considered);
2145       }
2146       return;
2147     }
2148     if (!$self->considered) {
2149       $self->considered = solv_calloc(1, sizeof(Map));
2150       map_init($self->considered, $self->nsolvables);
2151     }
2152     map_setall($self->considered);
2153     for (i = 0; i < q.count; i++) {
2154       p = q.elements[i];
2155       if (p > 0 && p < $self->nsolvables)
2156         MAPCLR($self->considered, p);
2157     }
2158   }
2159
2160   void setpooljobs(Queue solvejobs) {
2161     queue_free(&$self->pooljobs);
2162     queue_init_clone(&$self->pooljobs, &solvejobs);
2163   }
2164   %typemap(out) Queue getpooljobs Queue2Array(Job *, 2, new_Job(arg1, id, idp[1]));
2165   %newobject getpooljobs;
2166   Queue getpooljobs() {
2167     Queue q;
2168     queue_init_clone(&q, &$self->pooljobs);
2169     return q;
2170   }
2171
2172 }
2173
2174 %extend Repo {
2175   static const int REPO_REUSE_REPODATA = REPO_REUSE_REPODATA;
2176   static const int REPO_NO_INTERNALIZE = REPO_NO_INTERNALIZE;
2177   static const int REPO_LOCALPOOL = REPO_LOCALPOOL;
2178   static const int REPO_USE_LOADING = REPO_USE_LOADING;
2179   static const int REPO_EXTEND_SOLVABLES = REPO_EXTEND_SOLVABLES;
2180   static const int REPO_USE_ROOTDIR = REPO_USE_ROOTDIR;
2181   static const int REPO_NO_LOCATION = REPO_NO_LOCATION;
2182   static const int SOLV_ADD_NO_STUBS = SOLV_ADD_NO_STUBS;       /* repo_solv */
2183 #ifdef ENABLE_SUSEREPO
2184   static const int SUSETAGS_RECORD_SHARES = SUSETAGS_RECORD_SHARES;     /* repo_susetags */
2185 #endif
2186
2187   void free(bool reuseids = 0) {
2188     appdata_clr_helper(&$self->appdata);
2189     repo_free($self, reuseids);
2190   }
2191   void empty(bool reuseids = 0) {
2192     repo_empty($self, reuseids);
2193   }
2194 #ifdef SWIGRUBY
2195   %rename("isempty?") isempty;
2196 #endif
2197   bool isempty() {
2198     return !$self->nsolvables;
2199   }
2200
2201   AppObjectPtr appdata;
2202   %{
2203   SWIGINTERN void Repo_appdata_set(Repo *repo, AppObjectPtr appdata) {
2204     appdata_set_helper(&repo->appdata, appdata);
2205   }
2206   SWIGINTERN AppObjectPtr Repo_appdata_get(Repo *repo) {
2207     return appdata_get_helper(repo->appdata);
2208   }
2209   %}
2210
2211   bool add_solv(const char *name, int flags = 0) {
2212     FILE *fp = fopen(name, "r");
2213     int r;
2214     if (!fp)
2215       return 0;
2216     r = repo_add_solv($self, fp, flags);
2217     fclose(fp);
2218     return r == 0;
2219   }
2220   bool add_solv(FILE *fp, int flags = 0) {
2221     return repo_add_solv($self, fp, flags) == 0;
2222   }
2223
2224   %newobject add_solvable;
2225   XSolvable *add_solvable() {
2226     Id solvid = repo_add_solvable($self);
2227     return new_XSolvable($self->pool, solvid);
2228   }
2229
2230 #ifdef ENABLE_RPMDB
2231   bool add_rpmdb(int flags = 0) {
2232     return repo_add_rpmdb($self, 0, flags) == 0;
2233   }
2234   bool add_rpmdb_reffp(FILE *reffp, int flags = 0) {
2235     return repo_add_rpmdb_reffp($self, reffp, flags) == 0;
2236   }
2237 #endif
2238 #ifdef ENABLE_RPMPKG
2239   %newobject add_rpm;
2240   XSolvable *add_rpm(const char *name, int flags = 0) {
2241     return new_XSolvable($self->pool, repo_add_rpm($self, name, flags));
2242   }
2243 #endif
2244 #ifdef ENABLE_PUBKEY
2245 #ifdef ENABLE_RPMDB
2246   bool add_rpmdb_pubkeys(int flags = 0) {
2247     return repo_add_rpmdb_pubkeys($self, flags) == 0;
2248   }
2249 #endif
2250   %newobject add_pubkey;
2251   XSolvable *add_pubkey(const char *keyfile, int flags = 0) {
2252     return new_XSolvable($self->pool, repo_add_pubkey($self, keyfile, flags));
2253   }
2254   bool add_keyring(FILE *fp, int flags = 0) {
2255     return repo_add_keyring($self, fp, flags);
2256   }
2257   bool add_keydir(const char *keydir, const char *suffix, int flags = 0) {
2258     return repo_add_keydir($self, keydir, suffix, flags);
2259   }
2260 #endif
2261 #ifdef ENABLE_RPMMD
2262   bool add_rpmmd(FILE *fp, const char *language, int flags = 0) {
2263     return repo_add_rpmmd($self, fp, language, flags) == 0;
2264   }
2265   bool add_repomdxml(FILE *fp, int flags = 0) {
2266     return repo_add_repomdxml($self, fp, flags) == 0;
2267   }
2268   bool add_updateinfoxml(FILE *fp, int flags = 0) {
2269     return repo_add_updateinfoxml($self, fp, flags) == 0;
2270   }
2271   bool add_deltainfoxml(FILE *fp, int flags = 0) {
2272     return repo_add_deltainfoxml($self, fp, flags) == 0;
2273   }
2274 #endif
2275 #ifdef ENABLE_DEBIAN
2276   bool add_debdb(int flags = 0) {
2277     return repo_add_debdb($self, flags) == 0;
2278   }
2279   bool add_debpackages(FILE *fp, int flags = 0) {
2280     return repo_add_debpackages($self, fp, flags) == 0;
2281   }
2282   %newobject add_deb;
2283   XSolvable *add_deb(const char *name, int flags = 0) {
2284     return new_XSolvable($self->pool, repo_add_deb($self, name, flags));
2285   }
2286 #endif
2287 #ifdef ENABLE_SUSEREPO
2288   bool add_susetags(FILE *fp, Id defvendor, const char *language, int flags = 0) {
2289     return repo_add_susetags($self, fp, defvendor, language, flags) == 0;
2290   }
2291   bool add_content(FILE *fp, int flags = 0) {
2292     return repo_add_content($self, fp, flags) == 0;
2293   }
2294   bool add_products(const char *proddir, int flags = 0) {
2295     return repo_add_products($self, proddir, flags) == 0;
2296   }
2297 #endif
2298 #ifdef ENABLE_MDKREPO
2299   bool add_mdk(FILE *fp, int flags = 0) {
2300     return repo_add_mdk($self, fp, flags) == 0;
2301   }
2302   bool add_mdk_info(FILE *fp, int flags = 0) {
2303     return repo_add_mdk_info($self, fp, flags) == 0;
2304   }
2305 #endif
2306 #ifdef ENABLE_ARCHREPO
2307   bool add_arch_repo(FILE *fp, int flags = 0) {
2308     return repo_add_arch_repo($self, fp, flags) == 0;
2309   }
2310   bool add_arch_local(const char *dir, int flags = 0) {
2311     return repo_add_arch_local($self, dir, flags) == 0;
2312   }
2313   %newobject add_arch_pkg;
2314   XSolvable *add_arch_pkg(const char *name, int flags = 0) {
2315     return new_XSolvable($self->pool, repo_add_arch_pkg($self, name, flags));
2316   }
2317 #endif
2318 #ifdef SUSE
2319   bool add_autopattern(int flags = 0) {
2320     return repo_add_autopattern($self, flags) == 0;
2321   }
2322 #endif
2323   void internalize() {
2324     repo_internalize($self);
2325   }
2326   bool write(FILE *fp) {
2327     return repo_write($self, fp) == 0;
2328   }
2329   /* HACK, remove if no longer needed! */
2330   bool write_first_repodata(FILE *fp) {
2331     int oldnrepodata = $self->nrepodata;
2332     int res;
2333     $self->nrepodata = oldnrepodata > 2 ? 2 : oldnrepodata;
2334     res = repo_write($self, fp);
2335     $self->nrepodata = oldnrepodata;
2336     return res == 0;
2337   }
2338
2339   %newobject Dataiterator;
2340   Dataiterator *Dataiterator(Id key, const char *match = 0, int flags = 0) {
2341     return new_Dataiterator($self->pool, $self, 0, key, match, flags);
2342   }
2343   %newobject Dataiterator_meta;
2344   Dataiterator *Dataiterator_meta(Id key, const char *match = 0, int flags = 0) {
2345     return new_Dataiterator($self->pool, $self, SOLVID_META, key, match, flags);
2346   }
2347
2348   Id const id;
2349   %{
2350   SWIGINTERN Id Repo_id_get(Repo *repo) {
2351     return repo->repoid;
2352   }
2353   %}
2354   %newobject solvables;
2355   Repo_solvable_iterator * const solvables;
2356   %{
2357   SWIGINTERN Repo_solvable_iterator * Repo_solvables_get(Repo *repo) {
2358     return new_Repo_solvable_iterator(repo);
2359   }
2360   %}
2361   %newobject meta;
2362   Datapos * const meta;
2363   %{
2364   SWIGINTERN Datapos * Repo_meta_get(Repo *repo) {
2365     Datapos *pos = solv_calloc(1, sizeof(*pos));
2366     pos->solvid = SOLVID_META;
2367     pos->repo = repo;
2368     return pos;
2369   }
2370   %}
2371
2372   %newobject solvables_iter;
2373   Repo_solvable_iterator *solvables_iter() {
2374     return new_Repo_solvable_iterator($self);
2375   }
2376
2377   %newobject add_repodata;
2378   XRepodata *add_repodata(int flags = 0) {
2379     Repodata *rd = repo_add_repodata($self, flags);
2380     return new_XRepodata($self, rd->repodataid);
2381   }
2382
2383   void create_stubs() {
2384     Repodata *data;
2385     if (!$self->nrepodata)
2386       return;
2387     data = repo_id2repodata($self, $self->nrepodata - 1);
2388     if (data->state != REPODATA_STUB)
2389       (void)repodata_create_stubs(data);
2390   }
2391 #ifdef SWIGRUBY
2392   %rename("iscontiguous?") iscontiguous;
2393 #endif
2394   bool iscontiguous() {
2395     int i;
2396     for (i = $self->start; i < $self->end; i++)
2397       if ($self->pool->solvables[i].repo != $self)
2398         return 0;
2399     return 1;
2400   }
2401   %newobject first_repodata;
2402   XRepodata *first_repodata() {
2403     Repodata *data;
2404     int i;
2405     if ($self->nrepodata < 2)
2406       return 0;
2407     /* make sure all repodatas but the first are extensions */
2408     data = repo_id2repodata($self, 1);
2409     if (data->loadcallback)
2410        return 0;
2411     for (i = 2; i < $self->nrepodata; i++)
2412       {
2413         data = repo_id2repodata($self, i);
2414         if (!data->loadcallback)
2415           return 0;       /* oops, not an extension */
2416       }
2417     return new_XRepodata($self, 1);
2418   }
2419
2420   %newobject Selection;
2421   Selection *Selection(int setflags=0) {
2422     Selection *sel = new_Selection($self->pool);
2423     setflags |= SOLVER_SETREPO;
2424     queue_push2(&sel->q, SOLVER_SOLVABLE_REPO | setflags, $self->repoid);
2425     return sel;
2426   }
2427
2428 #ifdef ENABLE_PUBKEY
2429   %newobject find_pubkey;
2430   XSolvable *find_pubkey(const char *keyid) {
2431     return new_XSolvable($self->pool, repo_find_pubkey($self, keyid));
2432   }
2433 #endif
2434
2435   Repo *createshadow(const char *name) {
2436     Repo *repo = repo_create($self->pool, name);
2437     if ($self->idarraysize) {
2438       repo_reserve_ids(repo, 0, $self->idarraysize);
2439       memcpy(repo->idarraydata, $self->idarraydata, sizeof(Id) * $self->idarraysize);
2440       repo->idarraysize = $self->idarraysize;
2441     }
2442     repo->start = $self->start;
2443     repo->end = $self->end;
2444     repo->nsolvables = $self->nsolvables;
2445     return repo;
2446   }
2447
2448   void moveshadow(Queue q) {
2449     Pool *pool = $self->pool;
2450     int i;
2451     for (i = 0; i < q.count; i++) {
2452       Solvable *s;
2453       Id p = q.elements[i];
2454       if (p < $self->start || p >= $self->end)
2455         continue;
2456       s = pool->solvables + p;
2457       if ($self->idarraysize != s->repo->idarraysize)
2458         continue;
2459       s->repo = $self;
2460     }
2461   }
2462
2463 #if defined(SWIGTCL)
2464   %rename("==") __eq__;
2465 #endif
2466   bool __eq__(Repo *repo) {
2467     return $self == repo;
2468   }
2469 #if defined(SWIGTCL)
2470   %rename("!=") __ne__;
2471 #endif
2472   bool __ne__(Repo *repo) {
2473     return $self != repo;
2474   }
2475 #if defined(SWIGPYTHON)
2476   int __hash__() {
2477     return $self->repoid;
2478   }
2479 #endif
2480 #if defined(SWIGPERL) || defined(SWIGTCL)
2481   %rename("str") __str__;
2482 #endif
2483   %newobject __str__;
2484   const char *__str__() {
2485     char buf[20];
2486     if ($self->name)
2487       return solv_strdup($self->name);
2488     sprintf(buf, "Repo#%d", $self->repoid);
2489     return solv_strdup(buf);
2490   }
2491 #if defined(SWIGPERL) || defined(SWIGTCL)
2492   %rename("repr") __repr__;
2493 #endif
2494   %newobject __repr__;
2495   const char *__repr__() {
2496     char buf[20];
2497     if ($self->name)
2498       {
2499         sprintf(buf, "<Repo #%d ", $self->repoid);
2500         return solv_dupjoin(buf, $self->name, ">");
2501       }
2502     sprintf(buf, "<Repo #%d>", $self->repoid);
2503     return solv_strdup(buf);
2504   }
2505 }
2506
2507 %extend Dataiterator {
2508   static const int SEARCH_STRING = SEARCH_STRING;
2509   static const int SEARCH_STRINGSTART = SEARCH_STRINGSTART;
2510   static const int SEARCH_STRINGEND = SEARCH_STRINGEND;
2511   static const int SEARCH_SUBSTRING = SEARCH_SUBSTRING;
2512   static const int SEARCH_GLOB = SEARCH_GLOB;
2513   static const int SEARCH_REGEX = SEARCH_REGEX;
2514   static const int SEARCH_NOCASE = SEARCH_NOCASE;
2515   static const int SEARCH_FILES = SEARCH_FILES;
2516   static const int SEARCH_COMPLETE_FILELIST = SEARCH_COMPLETE_FILELIST;
2517   static const int SEARCH_CHECKSUMS = SEARCH_CHECKSUMS;
2518
2519   Dataiterator(Pool *pool, Repo *repo, Id p, Id key, const char *match, int flags) {
2520     Dataiterator *di = solv_calloc(1, sizeof(*di));
2521     dataiterator_init(di, pool, repo, p, key, match, flags);
2522     return di;
2523   }
2524   ~Dataiterator() {
2525     dataiterator_free($self);
2526     solv_free($self);
2527   }
2528 #if defined(SWIGPYTHON)
2529   %pythoncode {
2530     def __iter__(self): return self
2531   }
2532 #ifndef PYTHON3
2533   %rename("next") __next__();
2534 #endif
2535   %exception __next__ {
2536     $action
2537     if (!result) {
2538       PyErr_SetString(PyExc_StopIteration,"no more matches");
2539       return NULL;
2540     }
2541   }
2542 #endif
2543 #ifdef SWIGPERL
2544   perliter(solv::Dataiterator)
2545 #endif
2546   %newobject __next__;
2547   Datamatch *__next__() {
2548     Dataiterator *ndi;
2549     if (!dataiterator_step($self)) {
2550       return 0;
2551     }
2552     ndi = solv_calloc(1, sizeof(*ndi));
2553     dataiterator_init_clone(ndi, $self);
2554     dataiterator_strdup(ndi);
2555     return ndi;
2556   }
2557 #ifdef SWIGRUBY
2558   void each() {
2559     Datamatch *d;
2560     while ((d = Dataiterator___next__($self)) != 0) {
2561       rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(d), SWIGTYPE_p_Datamatch, SWIG_POINTER_OWN | 0));
2562     }
2563   }
2564 #endif
2565   void prepend_keyname(Id key) {
2566     dataiterator_prepend_keyname($self, key);
2567   }
2568   void skip_solvable() {
2569     dataiterator_skip_solvable($self);
2570   }
2571 }
2572
2573 %extend Datapos {
2574   Id lookup_id(Id keyname) {
2575     Pool *pool = $self->repo->pool;
2576     Datapos oldpos = pool->pos;
2577     Id r;
2578     pool->pos = *$self;
2579     r = pool_lookup_id(pool, SOLVID_POS, keyname);
2580     pool->pos = oldpos;
2581     return r;
2582   }
2583   const char *lookup_str(Id keyname) {
2584     Pool *pool = $self->repo->pool;
2585     Datapos oldpos = pool->pos;
2586     const char *r;
2587     pool->pos = *$self;
2588     r = pool_lookup_str(pool, SOLVID_POS, keyname);
2589     pool->pos = oldpos;
2590     return r;
2591   }
2592   unsigned long long lookup_num(Id keyname, unsigned long long notfound = 0) {
2593     Pool *pool = $self->repo->pool;
2594     Datapos oldpos = pool->pos;
2595     unsigned long long r;
2596     pool->pos = *$self;
2597     r = pool_lookup_num(pool, SOLVID_POS, keyname, notfound);
2598     pool->pos = oldpos;
2599     return r;
2600   }
2601   bool lookup_void(Id keyname) {
2602     Pool *pool = $self->repo->pool;
2603     Datapos oldpos = pool->pos;
2604     int r;
2605     pool->pos = *$self;
2606     r = pool_lookup_void(pool, SOLVID_POS, keyname);
2607     pool->pos = oldpos;
2608     return r;
2609   }
2610   %newobject lookup_checksum;
2611   Chksum *lookup_checksum(Id keyname) {
2612     Pool *pool = $self->repo->pool;
2613     Datapos oldpos = pool->pos;
2614     Id type = 0;
2615     const unsigned char *b;
2616     pool->pos = *$self;
2617     b = pool_lookup_bin_checksum(pool, SOLVID_POS, keyname, &type);
2618     pool->pos = oldpos;
2619     return solv_chksum_create_from_bin(type, b);
2620   }
2621   const char *lookup_deltaseq() {
2622     Pool *pool = $self->repo->pool;
2623     Datapos oldpos = pool->pos;
2624     const char *seq;
2625     pool->pos = *$self;
2626     seq = pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_NAME);
2627     if (seq) {
2628       seq = pool_tmpjoin(pool, seq, "-", pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_EVR));
2629       seq = pool_tmpappend(pool, seq, "-", pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_NUM));
2630     }
2631     pool->pos = oldpos;
2632     return seq;
2633   }
2634   const char *lookup_deltalocation(unsigned int *OUTPUT) {
2635     Pool *pool = $self->repo->pool;
2636     Datapos oldpos = pool->pos;
2637     const char *loc;
2638     pool->pos = *$self;
2639     loc = pool_lookup_deltalocation(pool, SOLVID_POS, OUTPUT);
2640     pool->pos = oldpos;
2641     return loc;
2642   }
2643   Queue lookup_idarray(Id keyname) {
2644     Pool *pool = $self->repo->pool;
2645     Datapos oldpos = pool->pos;
2646     Queue r;
2647     queue_init(&r);
2648     pool->pos = *$self;
2649     pool_lookup_idarray(pool, SOLVID_POS, keyname, &r);
2650     pool->pos = oldpos;
2651     return r;
2652   }
2653   %newobject Dataiterator;
2654   Dataiterator *Dataiterator(Id key, const char *match = 0, int flags = 0) {
2655     Pool *pool = $self->repo->pool;
2656     Datapos oldpos = pool->pos;
2657     Dataiterator *di;
2658     pool->pos = *$self;
2659     di = new_Dataiterator(pool, 0, SOLVID_POS, key, match, flags);
2660     pool->pos = oldpos;
2661     return di;
2662   }
2663 }
2664
2665 %extend Datamatch {
2666   ~Datamatch() {
2667     dataiterator_free($self);
2668     solv_free($self);
2669   }
2670   %newobject solvable;
2671   XSolvable * const solvable;
2672   Id const key_id;
2673   const char * const key_idstr;
2674   Id const type_id;
2675   const char * const type_idstr;
2676   Id const id;
2677   const char * const idstr;
2678   const char * const str;
2679   BinaryBlob const binary;
2680   unsigned long long const num;
2681   unsigned int const num2;
2682   %{
2683   SWIGINTERN XSolvable *Datamatch_solvable_get(Dataiterator *di) {
2684     return new_XSolvable(di->pool, di->solvid);
2685   }
2686   SWIGINTERN Id Datamatch_key_id_get(Dataiterator *di) {
2687     return di->key->name;
2688   }
2689   SWIGINTERN const char *Datamatch_key_idstr_get(Dataiterator *di) {
2690     return pool_id2str(di->pool, di->key->name);
2691   }
2692   SWIGINTERN Id Datamatch_type_id_get(Dataiterator *di) {
2693     return di->key->type;
2694   }
2695   SWIGINTERN const char *Datamatch_type_idstr_get(Dataiterator *di) {
2696     return pool_id2str(di->pool, di->key->type);
2697   }
2698   SWIGINTERN Id Datamatch_id_get(Dataiterator *di) {
2699     return di->kv.id;
2700   }
2701   SWIGINTERN const char *Datamatch_idstr_get(Dataiterator *di) {
2702    if (di->data && (di->key->type == REPOKEY_TYPE_DIR || di->key->type == REPOKEY_TYPE_DIRSTRARRAY || di->key->type == REPOKEY_TYPE_DIRNUMNUMARRAY))
2703       return repodata_dir2str(di->data,  di->kv.id, 0);
2704     if (di->data && di->data->localpool)
2705       return stringpool_id2str(&di->data->spool, di->kv.id);
2706     return pool_id2str(di->pool, di->kv.id);
2707   }
2708   SWIGINTERN const char * const Datamatch_str_get(Dataiterator *di) {
2709     return di->kv.str;
2710   }
2711   SWIGINTERN BinaryBlob Datamatch_binary_get(Dataiterator *di) {
2712     BinaryBlob bl;
2713     bl.data = 0;
2714     bl.len = 0;
2715     if (di->key->type == REPOKEY_TYPE_BINARY)
2716       {
2717         bl.data = di->kv.str;
2718         bl.len = di->kv.num;
2719       }
2720     else if ((bl.len = solv_chksum_len(di->key->type)) != 0)
2721       bl.data = di->kv.str;
2722     return bl;
2723   }
2724   SWIGINTERN unsigned long long Datamatch_num_get(Dataiterator *di) {
2725    if (di->key->type == REPOKEY_TYPE_NUM)
2726      return SOLV_KV_NUM64(&di->kv);
2727    return di->kv.num;
2728   }
2729   SWIGINTERN unsigned int Datamatch_num2_get(Dataiterator *di) {
2730     return di->kv.num2;
2731   }
2732   %}
2733   %newobject pos;
2734   Datapos *pos() {
2735     Pool *pool = $self->pool;
2736     Datapos *pos, oldpos = pool->pos;
2737     dataiterator_setpos($self);
2738     pos = solv_calloc(1, sizeof(*pos));
2739     *pos = pool->pos;
2740     pool->pos = oldpos;
2741     return pos;
2742   }
2743   %newobject parentpos;
2744   Datapos *parentpos() {
2745     Pool *pool = $self->pool;
2746     Datapos *pos, oldpos = pool->pos;
2747     dataiterator_setpos_parent($self);
2748     pos = solv_calloc(1, sizeof(*pos));
2749     *pos = pool->pos;
2750     pool->pos = oldpos;
2751     return pos;
2752   }
2753 #if defined(SWIGPERL)
2754   /* cannot use str here because swig reports a bogus conflict... */
2755   %rename("stringify") __str__;
2756   %perlcode {
2757     *solv::Datamatch::str = *solvc::Datamatch_stringify;
2758   }
2759 #endif
2760 #if defined(SWIGTCL)
2761   %rename("stringify") __str__;
2762 #endif
2763   const char *__str__() {
2764     KeyValue kv = $self->kv;
2765     const char *str = repodata_stringify($self->pool, $self->data, $self->key, &kv, SEARCH_FILES | SEARCH_CHECKSUMS);
2766     return str ? str : "";
2767   }
2768 }
2769
2770 %extend Pool_solvable_iterator {
2771   Pool_solvable_iterator(Pool *pool) {
2772     Pool_solvable_iterator *s;
2773     s = solv_calloc(1, sizeof(*s));
2774     s->pool = pool;
2775     return s;
2776   }
2777 #if defined(SWIGPYTHON)
2778   %pythoncode {
2779     def __iter__(self): return self
2780   }
2781 #ifndef PYTHON3
2782   %rename("next") __next__();
2783 #endif
2784   %exception __next__ {
2785     $action
2786     if (!result) {
2787       PyErr_SetString(PyExc_StopIteration,"no more matches");
2788       return NULL;
2789     }
2790   }
2791 #endif
2792 #ifdef SWIGPERL
2793   perliter(solv::Pool_solvable_iterator)
2794 #endif
2795   %newobject __next__;
2796   XSolvable *__next__() {
2797     Pool *pool = $self->pool;
2798     if ($self->id >= pool->nsolvables)
2799       return 0;
2800     while (++$self->id < pool->nsolvables)
2801       if (pool->solvables[$self->id].repo)
2802         return new_XSolvable(pool, $self->id);
2803     return 0;
2804   }
2805 #ifdef SWIGRUBY
2806   void each() {
2807     XSolvable *n;
2808     while ((n = Pool_solvable_iterator___next__($self)) != 0) {
2809       rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
2810     }
2811   }
2812 #endif
2813   %newobject __getitem__;
2814   XSolvable *__getitem__(Id key) {
2815     Pool *pool = $self->pool;
2816     if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo)
2817       return new_XSolvable(pool, key);
2818     return 0;
2819   }
2820   int __len__() {
2821     return $self->pool->nsolvables;
2822   }
2823 }
2824
2825 %extend Pool_repo_iterator {
2826   Pool_repo_iterator(Pool *pool) {
2827     Pool_repo_iterator *s;
2828     s = solv_calloc(1, sizeof(*s));
2829     s->pool = pool;
2830     return s;
2831   }
2832 #if defined(SWIGPYTHON)
2833   %pythoncode {
2834     def __iter__(self): return self
2835   }
2836 #ifndef PYTHON3
2837   %rename("next") __next__();
2838 #endif
2839   %exception __next__ {
2840     $action
2841     if (!result) {
2842       PyErr_SetString(PyExc_StopIteration,"no more matches");
2843       return NULL;
2844     }
2845   }
2846 #endif
2847 #ifdef SWIGPERL
2848   perliter(solv::Pool_repo_iterator)
2849 #endif
2850   Repo *__next__() {
2851     Pool *pool = $self->pool;
2852     if ($self->id >= pool->nrepos)
2853       return 0;
2854     while (++$self->id < pool->nrepos) {
2855       Repo *r = pool_id2repo(pool, $self->id);
2856       if (r)
2857         return r;
2858     }
2859     return 0;
2860   }
2861 #ifdef SWIGRUBY
2862   void each() {
2863     Repo *n;
2864     while ((n = Pool_repo_iterator___next__($self)) != 0) {
2865       rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_Repo, 0 | 0));
2866     }
2867   }
2868 #endif
2869   Repo *__getitem__(Id key) {
2870     Pool *pool = $self->pool;
2871     if (key > 0 && key < pool->nrepos)
2872       return pool_id2repo(pool, key);
2873     return 0;
2874   }
2875   int __len__() {
2876     return $self->pool->nrepos;
2877   }
2878 }
2879
2880 %extend Repo_solvable_iterator {
2881   Repo_solvable_iterator(Repo *repo) {
2882     Repo_solvable_iterator *s;
2883     s = solv_calloc(1, sizeof(*s));
2884     s->repo = repo;
2885     return s;
2886   }
2887 #if defined(SWIGPYTHON)
2888   %pythoncode {
2889     def __iter__(self): return self
2890   }
2891 #ifndef PYTHON3
2892   %rename("next") __next__();
2893 #endif
2894   %exception __next__ {
2895     $action
2896     if (!result) {
2897       PyErr_SetString(PyExc_StopIteration,"no more matches");
2898       return NULL;
2899     }
2900   }
2901 #endif
2902 #ifdef SWIGPERL
2903   perliter(solv::Repo_solvable_iterator)
2904 #endif
2905   %newobject __next__;
2906   XSolvable *__next__() {
2907     Repo *repo = $self->repo;
2908     Pool *pool = repo->pool;
2909     if (repo->start > 0 && $self->id < repo->start)
2910       $self->id = repo->start - 1;
2911     if ($self->id >= repo->end)
2912       return 0;
2913     while (++$self->id < repo->end)
2914       if (pool->solvables[$self->id].repo == repo)
2915         return new_XSolvable(pool, $self->id);
2916     return 0;
2917   }
2918 #ifdef SWIGRUBY
2919   void each() {
2920     XSolvable *n;
2921     while ((n = Repo_solvable_iterator___next__($self)) != 0) {
2922       rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
2923     }
2924   }
2925 #endif
2926   %newobject __getitem__;
2927   XSolvable *__getitem__(Id key) {
2928     Repo *repo = $self->repo;
2929     Pool *pool = repo->pool;
2930     if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo == repo)
2931       return new_XSolvable(pool, key);
2932     return 0;
2933   }
2934   int __len__() {
2935     return $self->repo->pool->nsolvables;
2936   }
2937 }
2938
2939 %extend Dep {
2940   Dep(Pool *pool, Id id) {
2941     Dep *s;
2942     if (!id)
2943       return 0;
2944     s = solv_calloc(1, sizeof(*s));
2945     s->pool = pool;
2946     s->id = id;
2947     return s;
2948   }
2949   %newobject Rel;
2950   Dep *Rel(int flags, DepId evrid, bool create=1) {
2951     Id id = pool_rel2id($self->pool, $self->id, evrid, flags, create);
2952     if (!id)
2953       return 0;
2954     return new_Dep($self->pool, id);
2955   }
2956   %newobject Selection_name;
2957   Selection *Selection_name(int setflags=0) {
2958     Selection *sel = new_Selection($self->pool);
2959     if (ISRELDEP($self->id)) {
2960       Reldep *rd = GETRELDEP($self->pool, $self->id);
2961       if (rd->flags == REL_EQ) {
2962         setflags |= $self->pool->disttype == DISTTYPE_DEB || strchr(pool_id2str($self->pool, rd->evr), '-') != 0 ? SOLVER_SETEVR : SOLVER_SETEV;
2963         if (ISRELDEP(rd->name))
2964           rd = GETRELDEP($self->pool, rd->name);
2965       }
2966       if (rd->flags == REL_ARCH)
2967         setflags |= SOLVER_SETARCH;
2968     }
2969     queue_push2(&sel->q, SOLVER_SOLVABLE_NAME | setflags, $self->id);
2970     return sel;
2971   }
2972   %newobject Selection_provides;
2973   Selection *Selection_provides(int setflags=0) {
2974     Selection *sel = new_Selection($self->pool);
2975     if (ISRELDEP($self->id)) {
2976       Reldep *rd = GETRELDEP($self->pool, $self->id);
2977       if (rd->flags == REL_ARCH)
2978         setflags |= SOLVER_SETARCH;
2979     }
2980     queue_push2(&sel->q, SOLVER_SOLVABLE_PROVIDES | setflags, $self->id);
2981     return sel;
2982   }
2983   const char *str() {
2984     return pool_dep2str($self->pool, $self->id);
2985   }
2986 #if defined(SWIGTCL)
2987   %rename("==") __eq__;
2988 #endif
2989   bool __eq__(Dep *s) {
2990     return $self->pool == s->pool && $self->id == s->id;
2991   }
2992 #if defined(SWIGTCL)
2993   %rename("!=") __ne__;
2994 #endif
2995   bool __ne__(Dep *s) {
2996     return !Dep___eq__($self, s);
2997   }
2998 #if defined(SWIGPYTHON)
2999   int __hash__() {
3000     return $self->id;
3001   }
3002 #endif
3003 #if defined(SWIGPERL) || defined(SWIGTCL)
3004   %rename("str") __str__;
3005 #endif
3006   const char *__str__() {
3007     return pool_dep2str($self->pool, $self->id);
3008   }
3009 #if defined(SWIGPERL) || defined(SWIGTCL)
3010   %rename("repr") __repr__;
3011 #endif
3012   %newobject __repr__;
3013   const char *__repr__() {
3014     char buf[20];
3015     sprintf(buf, "<Id #%d ", $self->id);
3016     return solv_dupjoin(buf, pool_dep2str($self->pool, $self->id), ">");
3017   }
3018 }
3019
3020 %extend XSolvable {
3021   XSolvable(Pool *pool, Id id) {
3022     XSolvable *s;
3023     if (!id || id >= pool->nsolvables)
3024       return 0;
3025     s = solv_calloc(1, sizeof(*s));
3026     s->pool = pool;
3027     s->id = id;
3028     return s;
3029   }
3030   const char *str() {
3031     return pool_solvid2str($self->pool, $self->id);
3032   }
3033   const char *lookup_str(Id keyname) {
3034     return pool_lookup_str($self->pool, $self->id, keyname);
3035   }
3036   Id lookup_id(Id keyname) {
3037     return pool_lookup_id($self->pool, $self->id, keyname);
3038   }
3039   unsigned long long lookup_num(Id keyname, unsigned long long notfound = 0) {
3040     return pool_lookup_num($self->pool, $self->id, keyname, notfound);
3041   }
3042   bool lookup_void(Id keyname) {
3043     return pool_lookup_void($self->pool, $self->id, keyname);
3044   }
3045   %newobject lookup_checksum;
3046   Chksum *lookup_checksum(Id keyname) {
3047     Id type = 0;
3048     const unsigned char *b = pool_lookup_bin_checksum($self->pool, $self->id, keyname, &type);
3049     return solv_chksum_create_from_bin(type, b);
3050   }
3051   Queue lookup_idarray(Id keyname, Id marker = -1) {
3052     Solvable *s = $self->pool->solvables + $self->id;
3053     Queue r;
3054     queue_init(&r);
3055     solvable_lookup_deparray(s, keyname, &r, marker);
3056     return r;
3057   }
3058   %typemap(out) Queue lookup_deparray Queue2Array(Dep *, 1, new_Dep(arg1->pool, id));
3059   %newobject lookup_deparray;
3060   Queue lookup_deparray(Id keyname, Id marker = -1) {
3061     Solvable *s = $self->pool->solvables + $self->id;
3062     Queue r;
3063     queue_init(&r);
3064     solvable_lookup_deparray(s, keyname, &r, marker);
3065     return r;
3066   }
3067   const char *lookup_location(unsigned int *OUTPUT) {
3068     return solvable_lookup_location($self->pool->solvables + $self->id, OUTPUT);
3069   }
3070   const char *lookup_sourcepkg() {
3071     return solvable_lookup_sourcepkg($self->pool->solvables + $self->id);
3072   }
3073   %newobject Dataiterator;
3074   Dataiterator *Dataiterator(Id key, const char *match = 0, int flags = 0) {
3075     return new_Dataiterator($self->pool, 0, $self->id, key, match, flags);
3076   }
3077 #ifdef SWIGRUBY
3078   %rename("installable?") installable;
3079 #endif
3080   bool installable() {
3081     return pool_installable($self->pool, pool_id2solvable($self->pool, $self->id));
3082   }
3083 #ifdef SWIGRUBY
3084   %rename("isinstalled?") isinstalled;
3085 #endif
3086   bool isinstalled() {
3087     Pool *pool = $self->pool;
3088     return pool->installed && pool_id2solvable(pool, $self->id)->repo == pool->installed;
3089   }
3090
3091   const char *name;
3092   %{
3093     SWIGINTERN void XSolvable_name_set(XSolvable *xs, const char *name) {
3094       Pool *pool = xs->pool;
3095       pool->solvables[xs->id].name = pool_str2id(pool, name, 1);
3096     }
3097     SWIGINTERN const char *XSolvable_name_get(XSolvable *xs) {
3098       Pool *pool = xs->pool;
3099       return pool_id2str(pool, pool->solvables[xs->id].name);
3100     }
3101   %}
3102   Id nameid;
3103   %{
3104     SWIGINTERN void XSolvable_nameid_set(XSolvable *xs, Id nameid) {
3105       xs->pool->solvables[xs->id].name = nameid;
3106     }
3107     SWIGINTERN Id XSolvable_nameid_get(XSolvable *xs) {
3108       return xs->pool->solvables[xs->id].name;
3109     }
3110   %}
3111   const char *evr;
3112   %{
3113     SWIGINTERN void XSolvable_evr_set(XSolvable *xs, const char *evr) {
3114       Pool *pool = xs->pool;
3115       pool->solvables[xs->id].evr = pool_str2id(pool, evr, 1);
3116     }
3117     SWIGINTERN const char *XSolvable_evr_get(XSolvable *xs) {
3118       Pool *pool = xs->pool;
3119       return pool_id2str(pool, pool->solvables[xs->id].evr);
3120     }
3121   %}
3122   Id evrid;
3123   %{
3124     SWIGINTERN void XSolvable_evrid_set(XSolvable *xs, Id evrid) {
3125       xs->pool->solvables[xs->id].evr = evrid;
3126     }
3127     SWIGINTERN Id XSolvable_evrid_get(XSolvable *xs) {
3128       return xs->pool->solvables[xs->id].evr;
3129     }
3130   %}
3131   const char *arch;
3132   %{
3133     SWIGINTERN void XSolvable_arch_set(XSolvable *xs, const char *arch) {
3134       Pool *pool = xs->pool;
3135       pool->solvables[xs->id].arch = pool_str2id(pool, arch, 1);
3136     }
3137     SWIGINTERN const char *XSolvable_arch_get(XSolvable *xs) {
3138       Pool *pool = xs->pool;
3139       return pool_id2str(pool, pool->solvables[xs->id].arch);
3140     }
3141   %}
3142   Id archid;
3143   %{
3144     SWIGINTERN void XSolvable_archid_set(XSolvable *xs, Id archid) {
3145       xs->pool->solvables[xs->id].arch = archid;
3146     }
3147     SWIGINTERN Id XSolvable_archid_get(XSolvable *xs) {
3148       return xs->pool->solvables[xs->id].arch;
3149     }
3150   %}
3151   const char *vendor;
3152   %{
3153     SWIGINTERN void XSolvable_vendor_set(XSolvable *xs, const char *vendor) {
3154       Pool *pool = xs->pool;
3155       pool->solvables[xs->id].vendor = pool_str2id(pool, vendor, 1);
3156     }
3157     SWIGINTERN const char *XSolvable_vendor_get(XSolvable *xs) {
3158       Pool *pool = xs->pool;
3159       return pool_id2str(pool, pool->solvables[xs->id].vendor);
3160     }
3161   %}
3162   Id vendorid;
3163   %{
3164     SWIGINTERN void XSolvable_vendorid_set(XSolvable *xs, Id vendorid) {
3165       xs->pool->solvables[xs->id].vendor = vendorid;
3166     }
3167     SWIGINTERN Id XSolvable_vendorid_get(XSolvable *xs) {
3168       return xs->pool->solvables[xs->id].vendor;
3169     }
3170   %}
3171   Repo * const repo;
3172   %{
3173     SWIGINTERN Repo *XSolvable_repo_get(XSolvable *xs) {
3174       return xs->pool->solvables[xs->id].repo;
3175     }
3176   %}
3177
3178   /* old interface, please use the generic add_deparray instead */
3179   void add_provides(DepId id, Id marker = -1) {
3180     Solvable *s = $self->pool->solvables + $self->id;
3181     marker = solv_depmarker(SOLVABLE_PROVIDES, marker);
3182     s->provides = repo_addid_dep(s->repo, s->provides, id, marker);
3183   }
3184   void add_obsoletes(DepId id) {
3185     Solvable *s = $self->pool->solvables + $self->id;
3186     s->obsoletes = repo_addid_dep(s->repo, s->obsoletes, id, 0);
3187   }
3188   void add_conflicts(DepId id) {
3189     Solvable *s = $self->pool->solvables + $self->id;
3190     s->conflicts = repo_addid_dep(s->repo, s->conflicts, id, 0);
3191   }
3192   void add_requires(DepId id, Id marker = -1) {
3193     Solvable *s = $self->pool->solvables + $self->id;
3194     marker = solv_depmarker(SOLVABLE_REQUIRES, marker);
3195     s->requires = repo_addid_dep(s->repo, s->requires, id, marker);
3196   }
3197   void add_recommends(DepId id) {
3198     Solvable *s = $self->pool->solvables + $self->id;
3199     s->recommends = repo_addid_dep(s->repo, s->recommends, id, 0);
3200   }
3201   void add_suggests(DepId id) {
3202     Solvable *s = $self->pool->solvables + $self->id;
3203     s->suggests = repo_addid_dep(s->repo, s->suggests, id, 0);
3204   }
3205   void add_supplements(DepId id) {
3206     Solvable *s = $self->pool->solvables + $self->id;
3207     s->supplements = repo_addid_dep(s->repo, s->supplements, id, 0);
3208   }
3209   void add_enhances(DepId id) {
3210     Solvable *s = $self->pool->solvables + $self->id;
3211     s->enhances = repo_addid_dep(s->repo, s->enhances, id, 0);
3212   }
3213
3214   void unset(Id keyname) {
3215     Solvable *s = $self->pool->solvables + $self->id;
3216     repo_unset(s->repo, $self->id, keyname);
3217   }
3218
3219   void add_deparray(Id keyname, DepId id, Id marker = -1) {
3220     Solvable *s = $self->pool->solvables + $self->id;
3221     solvable_add_deparray(s, keyname, id, marker);
3222   }
3223
3224   %newobject Selection;
3225   Selection *Selection(int setflags=0) {
3226     Selection *sel = new_Selection($self->pool);
3227     queue_push2(&sel->q, SOLVER_SOLVABLE | setflags, $self->id);
3228     return sel;
3229   }
3230
3231 #ifdef SWIGRUBY
3232   %rename("identical?") identical;
3233 #endif
3234   bool identical(XSolvable *s2) {
3235     return solvable_identical($self->pool->solvables + $self->id, s2->pool->solvables + s2->id);
3236   }
3237   int evrcmp(XSolvable *s2) {
3238     return pool_evrcmp($self->pool, $self->pool->solvables[$self->id].evr, s2->pool->solvables[s2->id].evr, EVRCMP_COMPARE);
3239   }
3240 #ifdef SWIGRUBY
3241   %rename("matchesdep?") matchesdep;
3242 #endif
3243   bool matchesdep(Id keyname, DepId id, Id marker = -1) {
3244     return solvable_matchesdep($self->pool->solvables + $self->id, keyname, id, marker);
3245   }
3246
3247 #if defined(SWIGTCL)
3248   %rename("==") __eq__;
3249 #endif
3250   bool __eq__(XSolvable *s) {
3251     return $self->pool == s->pool && $self->id == s->id;
3252   }
3253 #if defined(SWIGTCL)
3254   %rename("!=") __ne__;
3255 #endif
3256   bool __ne__(XSolvable *s) {
3257     return !XSolvable___eq__($self, s);
3258   }
3259 #if defined(SWIGPYTHON)
3260   int __hash__() {
3261     return $self->id;
3262   }
3263 #endif
3264 #if defined(SWIGPERL) || defined(SWIGTCL)
3265   %rename("str") __str__;
3266 #endif
3267   const char *__str__() {
3268     return pool_solvid2str($self->pool, $self->id);
3269   }
3270 #if defined(SWIGPERL) || defined(SWIGTCL)
3271   %rename("repr") __repr__;
3272 #endif
3273   %newobject __repr__;
3274   const char *__repr__() {
3275     char buf[20];
3276     sprintf(buf, "<Solvable #%d ", $self->id);
3277     return solv_dupjoin(buf, pool_solvid2str($self->pool, $self->id), ">");
3278   }
3279 }
3280
3281 %extend Problem {
3282   Problem(Solver *solv, Id id) {
3283     Problem *p;
3284     p = solv_calloc(1, sizeof(*p));
3285     p->solv = solv;
3286     p->id = id;
3287     return p;
3288   }
3289   %newobject findproblemrule;
3290   XRule *findproblemrule() {
3291     Id r = solver_findproblemrule($self->solv, $self->id);
3292     return new_XRule($self->solv, r);
3293   }
3294   %newobject findallproblemrules;
3295   %typemap(out) Queue findallproblemrules Queue2Array(XRule *, 1, new_XRule(arg1->solv, id));
3296   Queue findallproblemrules(int unfiltered=0) {
3297     Solver *solv = $self->solv;
3298     Id probr;
3299     int i, j;
3300     Queue q;
3301     queue_init(&q);
3302     solver_findallproblemrules(solv, $self->id, &q);
3303     if (!unfiltered)
3304       {
3305         for (i = j = 0; i < q.count; i++)
3306           {
3307             SolverRuleinfo rclass;
3308             probr = q.elements[i];
3309             rclass = solver_ruleclass(solv, probr);
3310             if (rclass == SOLVER_RULE_UPDATE || rclass == SOLVER_RULE_JOB)
3311               continue;
3312             q.elements[j++] = probr;
3313           }
3314         if (j)
3315           queue_truncate(&q, j);
3316       }
3317     return q;
3318   }
3319   int solution_count() {
3320     return solver_solution_count($self->solv, $self->id);
3321   }
3322   %typemap(out) Queue solutions Queue2Array(Solution *, 1, new_Solution(arg1, id));
3323   %newobject solutions;
3324   Queue solutions() {
3325     Queue q;
3326     int i, cnt;
3327     queue_init(&q);
3328     cnt = solver_solution_count($self->solv, $self->id);
3329     for (i = 1; i <= cnt; i++)
3330       queue_push(&q, i);
3331     return q;
3332   }
3333 #if defined(SWIGPERL) || defined(SWIGTCL)
3334   %rename("str") __str__;
3335 #endif
3336   const char *__str__() {
3337     return solver_problem2str($self->solv, $self->id);
3338   }
3339 }
3340
3341 %extend Solution {
3342   Solution(Problem *p, Id id) {
3343     Solution *s;
3344     s = solv_calloc(1, sizeof(*s));
3345     s->solv = p->solv;
3346     s->problemid = p->id;
3347     s->id = id;
3348     return s;
3349   }
3350   int element_count() {
3351     return solver_solutionelement_count($self->solv, $self->problemid, $self->id);
3352   }
3353
3354   %typemap(out) Queue elements Queue2Array(Solutionelement *, 4, new_Solutionelement(arg1->solv, arg1->problemid, arg1->id, id, idp[1], idp[2], idp[3]));
3355   %newobject elements;
3356   Queue elements(bool expandreplaces=0) {
3357     Queue q;
3358     int i, cnt;
3359     queue_init(&q);
3360     cnt = solver_solutionelement_count($self->solv, $self->problemid, $self->id);
3361     for (i = 1; i <= cnt; i++)
3362       {
3363         Id p, rp, type;
3364         solver_next_solutionelement($self->solv, $self->problemid, $self->id, i - 1, &p, &rp);
3365         if (p > 0) {
3366           type = rp ? SOLVER_SOLUTION_REPLACE : SOLVER_SOLUTION_ERASE;
3367         } else {
3368           type = p;
3369           p = rp;
3370           rp = 0;
3371         }
3372         if (type == SOLVER_SOLUTION_REPLACE && expandreplaces) {
3373           int illegal = policy_is_illegal(self->solv, self->solv->pool->solvables + p, self->solv->pool->solvables + rp, 0);
3374           if (illegal) {
3375             if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0) {
3376               queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_DOWNGRADE);
3377               queue_push2(&q, p, rp);
3378             }
3379             if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0) {
3380               queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_ARCHCHANGE);
3381               queue_push2(&q, p, rp);
3382             }
3383             if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0) {
3384               queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_VENDORCHANGE);
3385               queue_push2(&q, p, rp);
3386             }
3387             if ((illegal & POLICY_ILLEGAL_NAMECHANGE) != 0) {
3388               queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_NAMECHANGE);
3389               queue_push2(&q, p, rp);
3390             }
3391             continue;
3392           }
3393         }
3394         queue_push2(&q, i, type);
3395         queue_push2(&q, p, rp);
3396       }
3397     return q;
3398   }
3399 }
3400
3401 %extend Solutionelement {
3402   Solutionelement(Solver *solv, Id problemid, Id solutionid, Id id, Id type, Id p, Id rp) {
3403     Solutionelement *e;
3404     e = solv_calloc(1, sizeof(*e));
3405     e->solv = solv;
3406     e->problemid = problemid;
3407     e->solutionid = id;
3408     e->id = id;
3409     e->type = type;
3410     e->p = p;
3411     e->rp = rp;
3412     return e;
3413   }
3414   const char *str() {
3415     Id p = $self->type;
3416     Id rp = $self->p;
3417     int illegal = 0;
3418     if (p == SOLVER_SOLUTION_ERASE)
3419       {
3420         p = rp;
3421         rp = 0;
3422       }
3423     else if (p == SOLVER_SOLUTION_REPLACE)
3424       {
3425         p = rp;
3426         rp = $self->rp;
3427       }
3428     else if (p == SOLVER_SOLUTION_REPLACE_DOWNGRADE)
3429       illegal = POLICY_ILLEGAL_DOWNGRADE;
3430     else if (p == SOLVER_SOLUTION_REPLACE_ARCHCHANGE)
3431       illegal = POLICY_ILLEGAL_ARCHCHANGE;
3432     else if (p == SOLVER_SOLUTION_REPLACE_VENDORCHANGE)
3433       illegal = POLICY_ILLEGAL_VENDORCHANGE;
3434     else if (p == SOLVER_SOLUTION_REPLACE_NAMECHANGE)
3435       illegal = POLICY_ILLEGAL_NAMECHANGE;
3436     if (illegal)
3437       return pool_tmpjoin($self->solv->pool, "allow ", policy_illegal2str($self->solv, illegal, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp), 0);
3438     return solver_solutionelement2str($self->solv, p, rp);
3439   }
3440   %typemap(out) Queue replaceelements Queue2Array(Solutionelement *, 1, new_Solutionelement(arg1->solv, arg1->problemid, arg1->solutionid, arg1->id, id, arg1->p, arg1->rp));
3441   %newobject replaceelements;
3442   Queue replaceelements() {
3443     Queue q;
3444     int illegal;
3445
3446     queue_init(&q);
3447     if ($self->type != SOLVER_SOLUTION_REPLACE || $self->p <= 0 || $self->rp <= 0)
3448       illegal = 0;
3449     else
3450       illegal = policy_is_illegal($self->solv, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp, 0);
3451     if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
3452       queue_push(&q, SOLVER_SOLUTION_REPLACE_DOWNGRADE);
3453     if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
3454       queue_push(&q, SOLVER_SOLUTION_REPLACE_ARCHCHANGE);
3455     if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
3456       queue_push(&q, SOLVER_SOLUTION_REPLACE_VENDORCHANGE);
3457     if ((illegal & POLICY_ILLEGAL_NAMECHANGE) != 0)
3458       queue_push(&q, SOLVER_SOLUTION_REPLACE_NAMECHANGE);
3459     if (!q.count)
3460       queue_push(&q, $self->type);
3461     return q;
3462   }
3463   int illegalreplace() {
3464     if ($self->type != SOLVER_SOLUTION_REPLACE || $self->p <= 0 || $self->rp <= 0)
3465       return 0;
3466     return policy_is_illegal($self->solv, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp, 0);
3467   }
3468   %newobject solvable;
3469   XSolvable * const solvable;
3470   %newobject replacement;
3471   XSolvable * const replacement;
3472   int const jobidx;
3473   %{
3474     SWIGINTERN XSolvable *Solutionelement_solvable_get(Solutionelement *e) {
3475       return new_XSolvable(e->solv->pool, e->p);
3476     }
3477     SWIGINTERN XSolvable *Solutionelement_replacement_get(Solutionelement *e) {
3478       return new_XSolvable(e->solv->pool, e->rp);
3479     }
3480     SWIGINTERN int Solutionelement_jobidx_get(Solutionelement *e) {
3481       if (e->type != SOLVER_SOLUTION_JOB && e->type != SOLVER_SOLUTION_POOLJOB)
3482         return -1;
3483       return (e->p - 1) / 2;
3484     }
3485   %}
3486   %newobject Job;
3487   Job *Job() {
3488     Id extraflags = solver_solutionelement_extrajobflags($self->solv, $self->problemid, $self->solutionid);
3489     if ($self->type == SOLVER_SOLUTION_JOB || $self->type == SOLVER_SOLUTION_POOLJOB)
3490       return new_Job($self->solv->pool, SOLVER_NOOP, 0);
3491     if ($self->type == SOLVER_SOLUTION_INFARCH || $self->type == SOLVER_SOLUTION_DISTUPGRADE || $self->type == SOLVER_SOLUTION_BEST)
3492       return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_NOTBYUSER|extraflags, $self->p);
3493     if ($self->type == SOLVER_SOLUTION_REPLACE || $self->type == SOLVER_SOLUTION_REPLACE_DOWNGRADE || $self->type == SOLVER_SOLUTION_REPLACE_ARCHCHANGE || $self->type == SOLVER_SOLUTION_REPLACE_VENDORCHANGE || $self->type == SOLVER_SOLUTION_REPLACE_NAMECHANGE)
3494       return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_NOTBYUSER|extraflags, $self->rp);
3495     if ($self->type == SOLVER_SOLUTION_ERASE)
3496       return new_Job($self->solv->pool, SOLVER_ERASE|SOLVER_SOLVABLE|extraflags, $self->p);
3497     return 0;
3498   }
3499 }
3500
3501 %extend Solver {
3502   static const int SOLVER_RULE_UNKNOWN = SOLVER_RULE_UNKNOWN;
3503   static const int SOLVER_RULE_PKG = SOLVER_RULE_PKG;
3504   static const int SOLVER_RULE_PKG_NOT_INSTALLABLE = SOLVER_RULE_PKG_NOT_INSTALLABLE;
3505   static const int SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP = SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP;
3506   static const int SOLVER_RULE_PKG_REQUIRES = SOLVER_RULE_PKG_REQUIRES;
3507   static const int SOLVER_RULE_PKG_SELF_CONFLICT = SOLVER_RULE_PKG_SELF_CONFLICT;
3508   static const int SOLVER_RULE_PKG_CONFLICTS = SOLVER_RULE_PKG_CONFLICTS;
3509   static const int SOLVER_RULE_PKG_SAME_NAME = SOLVER_RULE_PKG_SAME_NAME;
3510   static const int SOLVER_RULE_PKG_OBSOLETES = SOLVER_RULE_PKG_OBSOLETES;
3511   static const int SOLVER_RULE_PKG_IMPLICIT_OBSOLETES = SOLVER_RULE_PKG_IMPLICIT_OBSOLETES;
3512   static const int SOLVER_RULE_PKG_INSTALLED_OBSOLETES = SOLVER_RULE_PKG_INSTALLED_OBSOLETES;
3513   static const int SOLVER_RULE_UPDATE = SOLVER_RULE_UPDATE;
3514   static const int SOLVER_RULE_FEATURE = SOLVER_RULE_FEATURE;
3515   static const int SOLVER_RULE_JOB = SOLVER_RULE_JOB;
3516   static const int SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
3517   static const int SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM = SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
3518   static const int SOLVER_RULE_JOB_UNKNOWN_PACKAGE = SOLVER_RULE_JOB_UNKNOWN_PACKAGE;
3519   static const int SOLVER_RULE_JOB_UNSUPPORTED = SOLVER_RULE_JOB_UNSUPPORTED;
3520   static const int SOLVER_RULE_DISTUPGRADE = SOLVER_RULE_DISTUPGRADE;
3521   static const int SOLVER_RULE_INFARCH = SOLVER_RULE_INFARCH;
3522   static const int SOLVER_RULE_CHOICE = SOLVER_RULE_CHOICE;
3523   static const int SOLVER_RULE_LEARNT = SOLVER_RULE_LEARNT;
3524
3525   static const int SOLVER_SOLUTION_JOB = SOLVER_SOLUTION_JOB;
3526   static const int SOLVER_SOLUTION_POOLJOB = SOLVER_SOLUTION_POOLJOB;
3527   static const int SOLVER_SOLUTION_INFARCH = SOLVER_SOLUTION_INFARCH;
3528   static const int SOLVER_SOLUTION_DISTUPGRADE = SOLVER_SOLUTION_DISTUPGRADE;
3529   static const int SOLVER_SOLUTION_BEST = SOLVER_SOLUTION_BEST;
3530   static const int SOLVER_SOLUTION_ERASE = SOLVER_SOLUTION_ERASE;
3531   static const int SOLVER_SOLUTION_REPLACE = SOLVER_SOLUTION_REPLACE;
3532   static const int SOLVER_SOLUTION_REPLACE_DOWNGRADE = SOLVER_SOLUTION_REPLACE_DOWNGRADE;
3533   static const int SOLVER_SOLUTION_REPLACE_ARCHCHANGE = SOLVER_SOLUTION_REPLACE_ARCHCHANGE;
3534   static const int SOLVER_SOLUTION_REPLACE_VENDORCHANGE = SOLVER_SOLUTION_REPLACE_VENDORCHANGE;
3535   static const int SOLVER_SOLUTION_REPLACE_NAMECHANGE = SOLVER_SOLUTION_REPLACE_NAMECHANGE;
3536
3537   static const int POLICY_ILLEGAL_DOWNGRADE = POLICY_ILLEGAL_DOWNGRADE;
3538   static const int POLICY_ILLEGAL_ARCHCHANGE = POLICY_ILLEGAL_ARCHCHANGE;
3539   static const int POLICY_ILLEGAL_VENDORCHANGE = POLICY_ILLEGAL_VENDORCHANGE;
3540   static const int POLICY_ILLEGAL_NAMECHANGE = POLICY_ILLEGAL_NAMECHANGE;
3541
3542   static const int SOLVER_FLAG_ALLOW_DOWNGRADE = SOLVER_FLAG_ALLOW_DOWNGRADE;
3543   static const int SOLVER_FLAG_ALLOW_ARCHCHANGE = SOLVER_FLAG_ALLOW_ARCHCHANGE;
3544   static const int SOLVER_FLAG_ALLOW_VENDORCHANGE = SOLVER_FLAG_ALLOW_VENDORCHANGE;
3545   static const int SOLVER_FLAG_ALLOW_NAMECHANGE = SOLVER_FLAG_ALLOW_NAMECHANGE;
3546   static const int SOLVER_FLAG_ALLOW_UNINSTALL = SOLVER_FLAG_ALLOW_UNINSTALL;
3547   static const int SOLVER_FLAG_NO_UPDATEPROVIDE = SOLVER_FLAG_NO_UPDATEPROVIDE;
3548   static const int SOLVER_FLAG_SPLITPROVIDES = SOLVER_FLAG_SPLITPROVIDES;
3549   static const int SOLVER_FLAG_IGNORE_RECOMMENDED = SOLVER_FLAG_IGNORE_RECOMMENDED;
3550   static const int SOLVER_FLAG_ADD_ALREADY_RECOMMENDED = SOLVER_FLAG_ADD_ALREADY_RECOMMENDED;
3551   static const int SOLVER_FLAG_NO_INFARCHCHECK = SOLVER_FLAG_NO_INFARCHCHECK;
3552   static const int SOLVER_FLAG_BEST_OBEY_POLICY = SOLVER_FLAG_BEST_OBEY_POLICY;
3553   static const int SOLVER_FLAG_NO_AUTOTARGET = SOLVER_FLAG_NO_AUTOTARGET;
3554   static const int SOLVER_FLAG_DUP_ALLOW_DOWNGRADE = SOLVER_FLAG_DUP_ALLOW_DOWNGRADE;
3555   static const int SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE = SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE;
3556   static const int SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE = SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE;
3557   static const int SOLVER_FLAG_DUP_ALLOW_NAMECHANGE = SOLVER_FLAG_DUP_ALLOW_NAMECHANGE;
3558   static const int SOLVER_FLAG_KEEP_ORPHANS = SOLVER_FLAG_KEEP_ORPHANS;
3559   static const int SOLVER_FLAG_BREAK_ORPHANS = SOLVER_FLAG_BREAK_ORPHANS;
3560   static const int SOLVER_FLAG_FOCUS_INSTALLED = SOLVER_FLAG_FOCUS_INSTALLED;
3561   static const int SOLVER_FLAG_YUM_OBSOLETES = SOLVER_FLAG_YUM_OBSOLETES;
3562   static const int SOLVER_FLAG_NEED_UPDATEPROVIDE = SOLVER_FLAG_NEED_UPDATEPROVIDE;
3563   static const int SOLVER_FLAG_FOCUS_BEST = SOLVER_FLAG_FOCUS_BEST;
3564   static const int SOLVER_FLAG_STRONG_RECOMMENDS = SOLVER_FLAG_STRONG_RECOMMENDS;
3565   static const int SOLVER_FLAG_INSTALL_ALSO_UPDATES = SOLVER_FLAG_INSTALL_ALSO_UPDATES;
3566   static const int SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED = SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED;
3567
3568   static const int SOLVER_REASON_UNRELATED = SOLVER_REASON_UNRELATED;
3569   static const int SOLVER_REASON_UNIT_RULE = SOLVER_REASON_UNIT_RULE;
3570   static const int SOLVER_REASON_KEEP_INSTALLED = SOLVER_REASON_KEEP_INSTALLED;
3571   static const int SOLVER_REASON_RESOLVE_JOB = SOLVER_REASON_RESOLVE_JOB;
3572   static const int SOLVER_REASON_UPDATE_INSTALLED = SOLVER_REASON_UPDATE_INSTALLED;
3573   static const int SOLVER_REASON_CLEANDEPS_ERASE = SOLVER_REASON_CLEANDEPS_ERASE;
3574   static const int SOLVER_REASON_RESOLVE = SOLVER_REASON_RESOLVE;
3575   static const int SOLVER_REASON_WEAKDEP = SOLVER_REASON_WEAKDEP;
3576   static const int SOLVER_REASON_RESOLVE_ORPHAN = SOLVER_REASON_RESOLVE_ORPHAN;
3577   static const int SOLVER_REASON_RECOMMENDED = SOLVER_REASON_RECOMMENDED;
3578   static const int SOLVER_REASON_SUPPLEMENTED = SOLVER_REASON_SUPPLEMENTED;
3579
3580   /* legacy */
3581   static const int SOLVER_RULE_RPM = SOLVER_RULE_RPM;
3582
3583   ~Solver() {
3584     solver_free($self);
3585   }
3586
3587   int set_flag(int flag, int value) {
3588     return solver_set_flag($self, flag, value);
3589   }
3590   int get_flag(int flag) {
3591     return solver_get_flag($self, flag);
3592   }
3593
3594   %typemap(out) Queue solve Queue2Array(Problem *, 1, new_Problem(arg1, id));
3595   %newobject solve;
3596   Queue solve(Queue solvejobs) {
3597     Queue q;
3598     int i, cnt;
3599     queue_init(&q);
3600     solver_solve($self, &solvejobs);
3601     cnt = solver_problem_count($self);
3602     for (i = 1; i <= cnt; i++)
3603       queue_push(&q, i);
3604     return q;
3605   }
3606
3607   %newobject transaction;
3608   Transaction *transaction() {
3609     return solver_create_transaction($self);
3610   }
3611
3612   int describe_decision(XSolvable *s, XRule **OUTPUT) {
3613     int ruleid;
3614     int reason = solver_describe_decision($self, s->id, &ruleid);
3615     *OUTPUT = new_XRule($self, ruleid);
3616     return reason;
3617   }
3618
3619   %newobject describe_weakdep_decision_raw;
3620   Queue describe_weakdep_decision_raw(XSolvable *s) {
3621     Queue q;
3622     queue_init(&q);
3623     solver_describe_weakdep_decision($self, s->id, &q);
3624     return q;
3625   }
3626 #if defined(SWIGPYTHON)
3627   %pythoncode {
3628     def describe_weakdep_decision(self, s):
3629       d = iter(self.describe_weakdep_decision_raw(s))
3630       return [ (t, XSolvable(self.pool, sid), Dep(self.pool, id)) for t, sid, id in zip(d, d, d) ]
3631   }
3632 #endif
3633 #if defined(SWIGPERL)
3634   %perlcode {
3635     sub solv::Solver::describe_weakdep_decision {
3636       my ($self, $s) = @_;
3637       my $pool = $self->{'pool'};
3638       my @res;
3639       my @d = $self->describe_weakdep_decision_raw($s);
3640       push @res, [ splice(@d, 0, 3) ] while @d;
3641       return map { [ $_->[0], solv::XSolvable->new($pool, $_->[1]), solv::Dep->new($pool, $_->[2]) ] } @res;
3642     }
3643   }
3644 #endif
3645 #if defined(SWIGRUBY)
3646 %init %{
3647 rb_eval_string(
3648     "class Solv::Solver\n"
3649     "  def describe_weakdep_decision(s)\n"
3650     "    self.describe_weakdep_decision_raw(s).each_slice(3).map { |t, sid, id| [ t, Solv::XSolvable.new(self.pool, sid), Solv::Dep.new(self.pool, id)] }\n"
3651     "  end\n"
3652     "end\n"
3653   );
3654 %}
3655 #endif
3656
3657   int alternatives_count() {
3658     return solver_alternatives_count($self);
3659   }
3660
3661   %newobject alternative;
3662   Alternative *alternative(Id aid) {
3663     Alternative *a = solv_calloc(1, sizeof(*a));
3664     a->solv = $self;
3665     queue_init(&a->choices);
3666     a->type = solver_get_alternative($self, aid, &a->dep_id, &a->from_id, &a->chosen_id, &a->choices, &a->level);
3667     if (!a->type) {
3668       queue_free(&a->choices);
3669       solv_free(a);
3670       return 0;
3671     }
3672     if (a->type == SOLVER_ALTERNATIVE_TYPE_RULE) {
3673       a->rid = a->dep_id;
3674       a->dep_id = 0;
3675     }
3676     return a;
3677   }
3678
3679   %typemap(out) Queue all_alternatives Queue2Array(Alternative *, 1, Solver_alternative(arg1, id));
3680   %newobject all_alternatives;
3681   Queue all_alternatives() {
3682     Queue q;
3683     int i, cnt;
3684     queue_init(&q);
3685     cnt = solver_alternatives_count($self);
3686     for (i = 1; i <= cnt; i++)
3687       queue_push(&q, i);
3688     return q;
3689   }
3690
3691   bool write_testcase(const char *dir) {
3692     return testcase_write($self, dir, TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS, 0, 0);
3693   }
3694
3695   Queue raw_decisions(int filter=0) {
3696     Queue q;
3697     queue_init(&q);
3698     solver_get_decisionqueue($self, &q);
3699     if (filter) {
3700       int i, j;
3701       for (i = j = 0; i < q.count; i++)
3702         if ((filter > 0 && q.elements[i] > 1) ||
3703             (filter < 0 && q.elements[i] < 0))
3704           q.elements[j++] = q.elements[i];
3705       queue_truncate(&q, j);
3706     }
3707     return q;
3708   }
3709
3710   %typemap(out) Queue get_recommended Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3711   %newobject get_recommended;
3712   Queue get_recommended(bool noselected=0) {
3713     Queue q;
3714     queue_init(&q);
3715     solver_get_recommendations($self, &q, NULL, noselected);
3716     return q;
3717   }
3718   %typemap(out) Queue get_suggested Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3719   %newobject get_suggested;
3720   Queue get_suggested(bool noselected=0) {
3721     Queue q;
3722     queue_init(&q);
3723     solver_get_recommendations($self, NULL, &q, noselected);
3724     return q;
3725   }
3726 }
3727
3728 %extend Transaction {
3729   static const int SOLVER_TRANSACTION_IGNORE = SOLVER_TRANSACTION_IGNORE;
3730   static const int SOLVER_TRANSACTION_ERASE = SOLVER_TRANSACTION_ERASE;
3731   static const int SOLVER_TRANSACTION_REINSTALLED = SOLVER_TRANSACTION_REINSTALLED;
3732   static const int SOLVER_TRANSACTION_DOWNGRADED = SOLVER_TRANSACTION_DOWNGRADED;
3733   static const int SOLVER_TRANSACTION_CHANGED = SOLVER_TRANSACTION_CHANGED;
3734   static const int SOLVER_TRANSACTION_UPGRADED = SOLVER_TRANSACTION_UPGRADED;
3735   static const int SOLVER_TRANSACTION_OBSOLETED = SOLVER_TRANSACTION_OBSOLETED;
3736   static const int SOLVER_TRANSACTION_INSTALL = SOLVER_TRANSACTION_INSTALL;
3737   static const int SOLVER_TRANSACTION_REINSTALL = SOLVER_TRANSACTION_REINSTALL;
3738   static const int SOLVER_TRANSACTION_DOWNGRADE = SOLVER_TRANSACTION_DOWNGRADE;
3739   static const int SOLVER_TRANSACTION_CHANGE = SOLVER_TRANSACTION_CHANGE;
3740   static const int SOLVER_TRANSACTION_UPGRADE = SOLVER_TRANSACTION_UPGRADE;
3741   static const int SOLVER_TRANSACTION_OBSOLETES = SOLVER_TRANSACTION_OBSOLETES;
3742   static const int SOLVER_TRANSACTION_MULTIINSTALL = SOLVER_TRANSACTION_MULTIINSTALL;
3743   static const int SOLVER_TRANSACTION_MULTIREINSTALL = SOLVER_TRANSACTION_MULTIREINSTALL;
3744   static const int SOLVER_TRANSACTION_MAXTYPE = SOLVER_TRANSACTION_MAXTYPE;
3745   static const int SOLVER_TRANSACTION_SHOW_ACTIVE = SOLVER_TRANSACTION_SHOW_ACTIVE;
3746   static const int SOLVER_TRANSACTION_SHOW_ALL = SOLVER_TRANSACTION_SHOW_ALL;
3747   static const int SOLVER_TRANSACTION_SHOW_OBSOLETES = SOLVER_TRANSACTION_SHOW_OBSOLETES;
3748   static const int SOLVER_TRANSACTION_SHOW_MULTIINSTALL = SOLVER_TRANSACTION_SHOW_MULTIINSTALL;
3749   static const int SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = SOLVER_TRANSACTION_CHANGE_IS_REINSTALL;
3750   static const int SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE = SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE;
3751   static const int SOLVER_TRANSACTION_MERGE_VENDORCHANGES = SOLVER_TRANSACTION_MERGE_VENDORCHANGES;
3752   static const int SOLVER_TRANSACTION_MERGE_ARCHCHANGES = SOLVER_TRANSACTION_MERGE_ARCHCHANGES;
3753   static const int SOLVER_TRANSACTION_RPM_ONLY = SOLVER_TRANSACTION_RPM_ONLY;
3754   static const int SOLVER_TRANSACTION_ARCHCHANGE = SOLVER_TRANSACTION_ARCHCHANGE;
3755   static const int SOLVER_TRANSACTION_VENDORCHANGE = SOLVER_TRANSACTION_VENDORCHANGE;
3756   static const int SOLVER_TRANSACTION_KEEP_ORDERDATA = SOLVER_TRANSACTION_KEEP_ORDERDATA;
3757   ~Transaction() {
3758     transaction_free($self);
3759   }
3760 #ifdef SWIGRUBY
3761   %rename("isempty?") isempty;
3762 #endif
3763   bool isempty() {
3764     return $self->steps.count == 0;
3765   }
3766
3767   %newobject othersolvable;
3768   XSolvable *othersolvable(XSolvable *s) {
3769     Id op = transaction_obs_pkg($self, s->id);
3770     return new_XSolvable($self->pool, op);
3771   }
3772
3773   %typemap(out) Queue allothersolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3774   %newobject allothersolvables;
3775   Queue allothersolvables(XSolvable *s) {
3776     Queue q;
3777     queue_init(&q);
3778     transaction_all_obs_pkgs($self, s->id, &q);
3779     return q;
3780   }
3781
3782   %typemap(out) Queue classify Queue2Array(TransactionClass *, 4, new_TransactionClass(arg1, arg2, id, idp[1], idp[2], idp[3]));
3783   %newobject classify;
3784   Queue classify(int mode = 0) {
3785     Queue q;
3786     queue_init(&q);
3787     transaction_classify($self, mode, &q);
3788     return q;
3789   }
3790
3791   /* deprecated, use newsolvables instead */
3792   %typemap(out) Queue newpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3793   %newobject newpackages;
3794   Queue newpackages() {
3795     Queue q;
3796     int cut;
3797     queue_init(&q);
3798     cut = transaction_installedresult(self, &q);
3799     queue_truncate(&q, cut);
3800     return q;
3801   }
3802
3803   /* deprecated, use keptsolvables instead */
3804   %typemap(out) Queue keptpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3805   %newobject keptpackages;
3806   Queue keptpackages() {
3807     Queue q;
3808     int cut;
3809     queue_init(&q);
3810     cut = transaction_installedresult(self, &q);
3811     if (cut)
3812       queue_deleten(&q, 0, cut);
3813     return q;
3814   }
3815
3816   %typemap(out) Queue newsolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3817   %newobject newsolvables;
3818   Queue newsolvables() {
3819     Queue q;
3820     int cut;
3821     queue_init(&q);
3822     cut = transaction_installedresult(self, &q);
3823     queue_truncate(&q, cut);
3824     return q;
3825   }
3826
3827   %typemap(out) Queue keptsolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3828   %newobject keptsolvables;
3829   Queue keptsolvables() {
3830     Queue q;
3831     int cut;
3832     queue_init(&q);
3833     cut = transaction_installedresult(self, &q);
3834     if (cut)
3835       queue_deleten(&q, 0, cut);
3836     return q;
3837   }
3838
3839   %typemap(out) Queue steps Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
3840   %newobject steps;
3841   Queue steps() {
3842     Queue q;
3843     queue_init_clone(&q, &$self->steps);
3844     return q;
3845   }
3846
3847   int steptype(XSolvable *s, int mode) {
3848     return transaction_type($self, s->id, mode);
3849   }
3850   long long calc_installsizechange() {
3851     return transaction_calc_installsizechange($self);
3852   }
3853   void order(int flags=0) {
3854     transaction_order($self, flags);
3855   }
3856 }
3857
3858 %extend TransactionClass {
3859   TransactionClass(Transaction *trans, int mode, Id type, int count, Id fromid, Id toid) {
3860     TransactionClass *cl = solv_calloc(1, sizeof(*cl));
3861     cl->transaction = trans;
3862     cl->mode = mode;
3863     cl->type = type;
3864     cl->count = count;
3865     cl->fromid = fromid;
3866     cl->toid = toid;
3867     return cl;
3868   }
3869   %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->transaction->pool, id));
3870   %newobject solvables;
3871   Queue solvables() {
3872     Queue q;
3873     queue_init(&q);
3874     transaction_classify_pkgs($self->transaction, $self->mode, $self->type, $self->fromid, $self->toid, &q);
3875     return q;
3876   }
3877   const char * const fromstr;
3878   const char * const tostr;
3879   %{
3880     SWIGINTERN const char *TransactionClass_fromstr_get(TransactionClass *cl) {
3881       return pool_id2str(cl->transaction->pool, cl->fromid);
3882     }
3883     SWIGINTERN const char *TransactionClass_tostr_get(TransactionClass *cl) {
3884       return pool_id2str(cl->transaction->pool, cl->toid);
3885     }
3886   %}
3887 }
3888
3889 %extend XRule {
3890   XRule(Solver *solv, Id id) {
3891     if (!id)
3892       return 0;
3893     XRule *xr = solv_calloc(1, sizeof(*xr));
3894     xr->solv = solv;
3895     xr->id = id;
3896     return xr;
3897   }
3898   int const type;
3899   %{
3900     SWIGINTERN int XRule_type_get(XRule *xr) {
3901       return solver_ruleclass(xr->solv, xr->id);
3902     }
3903   %}
3904   %newobject info;
3905   Ruleinfo *info() {
3906     Id type, source, target, dep;
3907     type = solver_ruleinfo($self->solv, $self->id, &source, &target, &dep);
3908     return new_Ruleinfo($self, type, source, target, dep);
3909   }
3910   %typemap(out) Queue allinfos Queue2Array(Ruleinfo *, 4, new_Ruleinfo(arg1, id, idp[1], idp[2], idp[3]));
3911   %newobject allinfos;
3912   Queue allinfos() {
3913     Queue q;
3914     queue_init(&q);
3915     solver_allruleinfos($self->solv, $self->id, &q);
3916     return q;
3917   }
3918
3919 #if defined(SWIGTCL)
3920   %rename("==") __eq__;
3921 #endif
3922   bool __eq__(XRule *xr) {
3923     return $self->solv == xr->solv && $self->id == xr->id;
3924   }
3925 #if defined(SWIGTCL)
3926   %rename("!=") __ne__;
3927 #endif
3928   bool __ne__(XRule *xr) {
3929     return !XRule___eq__($self, xr);
3930   }
3931 #if defined(SWIGPYTHON)
3932   int __hash__() {
3933     return $self->id;
3934   }
3935 #endif
3936 #if defined(SWIGPERL) || defined(SWIGTCL)
3937   %rename("repr") __repr__;
3938 #endif
3939   %newobject __repr__;
3940   const char *__repr__() {
3941     char buf[20];
3942     sprintf(buf, "<Rule #%d>", $self->id);
3943     return solv_strdup(buf);
3944   }
3945 }
3946
3947 %extend Ruleinfo {
3948   Ruleinfo(XRule *r, Id type, Id source, Id target, Id dep_id) {
3949     Ruleinfo *ri = solv_calloc(1, sizeof(*ri));
3950     ri->solv = r->solv;
3951     ri->rid = r->id;
3952     ri->type = type;
3953     ri->source = source;
3954     ri->target = target;
3955     ri->dep_id = dep_id;
3956     return ri;
3957   }
3958   %newobject solvable;
3959   XSolvable * const solvable;
3960   %newobject othersolvable;
3961   XSolvable * const othersolvable;
3962   %newobject dep;
3963   Dep * const dep;
3964   %{
3965     SWIGINTERN XSolvable *Ruleinfo_solvable_get(Ruleinfo *ri) {
3966       return new_XSolvable(ri->solv->pool, ri->source);
3967     }
3968     SWIGINTERN XSolvable *Ruleinfo_othersolvable_get(Ruleinfo *ri) {
3969       return new_XSolvable(ri->solv->pool, ri->target);
3970     }
3971     SWIGINTERN Dep *Ruleinfo_dep_get(Ruleinfo *ri) {
3972       return new_Dep(ri->solv->pool, ri->dep_id);
3973     }
3974   %}
3975   const char *problemstr() {
3976     return solver_problemruleinfo2str($self->solv, $self->type, $self->source, $self->target, $self->dep_id);
3977   }
3978 }
3979
3980 %extend XRepodata {
3981   XRepodata(Repo *repo, Id id) {
3982     XRepodata *xr = solv_calloc(1, sizeof(*xr));
3983     xr->repo = repo;
3984     xr->id = id;
3985     return xr;
3986   }
3987   Id new_handle() {
3988     return repodata_new_handle(repo_id2repodata($self->repo, $self->id));
3989   }
3990   void set_id(Id solvid, Id keyname, DepId id) {
3991     repodata_set_id(repo_id2repodata($self->repo, $self->id), solvid, keyname, id);
3992   }
3993   void set_num(Id solvid, Id keyname, unsigned long long num) {
3994     repodata_set_num(repo_id2repodata($self->repo, $self->id), solvid, keyname, num);
3995   }
3996   void set_str(Id solvid, Id keyname, const char *str) {
3997     repodata_set_str(repo_id2repodata($self->repo, $self->id), solvid, keyname, str);
3998   }
3999   void set_void(Id solvid, Id keyname) {
4000     repodata_set_void(repo_id2repodata($self->repo, $self->id), solvid, keyname);
4001   }
4002   void set_poolstr(Id solvid, Id keyname, const char *str) {
4003     repodata_set_poolstr(repo_id2repodata($self->repo, $self->id), solvid, keyname, str);
4004   }
4005   void add_idarray(Id solvid, Id keyname, DepId id) {
4006     repodata_add_idarray(repo_id2repodata($self->repo, $self->id), solvid, keyname, id);
4007   }
4008   void add_flexarray(Id solvid, Id keyname, Id handle) {
4009     repodata_add_flexarray(repo_id2repodata($self->repo, $self->id), solvid, keyname, handle);
4010   }
4011   void set_checksum(Id solvid, Id keyname, Chksum *chksum) {
4012     const unsigned char *buf = solv_chksum_get(chksum, 0);
4013     if (buf)
4014       repodata_set_bin_checksum(repo_id2repodata($self->repo, $self->id), solvid, keyname, solv_chksum_get_type(chksum), buf);
4015   }
4016   void set_sourcepkg(Id solvid, const char *sourcepkg) {
4017     repodata_set_sourcepkg(repo_id2repodata($self->repo, $self->id), solvid, sourcepkg);
4018   }
4019   void set_location(Id solvid, unsigned int mediano, const char *location) {
4020     repodata_set_location(repo_id2repodata($self->repo, $self->id), solvid, mediano, 0, location);
4021   }
4022   void unset(Id solvid, Id keyname) {
4023     repodata_unset(repo_id2repodata($self->repo, $self->id), solvid, keyname);
4024   }
4025   const char *lookup_str(Id solvid, Id keyname) {
4026     return repodata_lookup_str(repo_id2repodata($self->repo, $self->id), solvid, keyname);
4027   }
4028   Id lookup_id(Id solvid, Id keyname) {
4029     return repodata_lookup_id(repo_id2repodata($self->repo, $self->id), solvid, keyname);
4030   }
4031   unsigned long long lookup_num(Id solvid, Id keyname, unsigned long long notfound = 0) {
4032     return repodata_lookup_num(repo_id2repodata($self->repo, $self->id), solvid, keyname, notfound);
4033   }
4034   bool lookup_void(Id solvid, Id keyname) {
4035     return repodata_lookup_void(repo_id2repodata($self->repo, $self->id), solvid, keyname);
4036   }
4037   Queue lookup_idarray(Id solvid, Id keyname) {
4038     Queue r;
4039     queue_init(&r);
4040     repodata_lookup_idarray(repo_id2repodata($self->repo, $self->id), solvid, keyname, &r);
4041     return r;
4042   }
4043   %newobject lookup_checksum;
4044   Chksum *lookup_checksum(Id solvid, Id keyname) {
4045     Id type = 0;
4046     const unsigned char *b = repodata_lookup_bin_checksum(repo_id2repodata($self->repo, $self->id), solvid, keyname, &type);
4047     return solv_chksum_create_from_bin(type, b);
4048   }
4049   void internalize() {
4050     repodata_internalize(repo_id2repodata($self->repo, $self->id));
4051   }
4052   void create_stubs() {
4053     Repodata *data = repo_id2repodata($self->repo, $self->id);
4054     data = repodata_create_stubs(data);
4055     $self->id = data->repodataid;
4056   }
4057   bool write(FILE *fp) {
4058     return repodata_write(repo_id2repodata($self->repo, $self->id), fp) == 0;
4059   }
4060   Id str2dir(const char *dir, bool create=1) {
4061     Repodata *data = repo_id2repodata($self->repo, $self->id);
4062     return repodata_str2dir(data, dir, create);
4063   }
4064   const char *dir2str(Id did, const char *suf = 0) {
4065     Repodata *data = repo_id2repodata($self->repo, $self->id);
4066     return repodata_dir2str(data, did, suf);
4067   }
4068   void add_dirstr(Id solvid, Id keyname, Id dir, const char *str) {
4069     Repodata *data = repo_id2repodata($self->repo, $self->id);
4070     repodata_add_dirstr(data, solvid, keyname, dir, str);
4071   }
4072   bool add_solv(FILE *fp, int flags = 0) {
4073     Repodata *data = repo_id2repodata($self->repo, $self->id);
4074     int r, oldstate = data->state;
4075     data->state = REPODATA_LOADING;
4076     r = repo_add_solv(data->repo, fp, flags | REPO_USE_LOADING);
4077     if (r || data->state == REPODATA_LOADING)
4078       data->state = oldstate;
4079     return r;
4080   }
4081   void extend_to_repo() {
4082     Repodata *data = repo_id2repodata($self->repo, $self->id);
4083     repodata_extend_block(data, data->repo->start, data->repo->end - data->repo->start);
4084   }
4085 #if defined(SWIGTCL)
4086   %rename("==") __eq__;
4087 #endif
4088   bool __eq__(XRepodata *xr) {
4089     return $self->repo == xr->repo && $self->id == xr->id;
4090   }
4091 #if defined(SWIGTCL)
4092   %rename("!=") __ne__;
4093 #endif
4094   bool __ne__(XRepodata *xr) {
4095     return !XRepodata___eq__($self, xr);
4096   }
4097 #if defined(SWIGPYTHON)
4098   int __hash__() {
4099     return $self->id;
4100   }
4101 #endif
4102 #if defined(SWIGPERL) || defined(SWIGTCL)
4103   %rename("repr") __repr__;
4104 #endif
4105   %newobject __repr__;
4106   const char *__repr__() {
4107     char buf[20];
4108     sprintf(buf, "<Repodata #%d>", $self->id);
4109     return solv_strdup(buf);
4110   }
4111 }
4112
4113 #ifdef ENABLE_PUBKEY
4114 %extend Solvsig {
4115   Solvsig(FILE *fp) {
4116     return solvsig_create(fp);
4117   }
4118   ~Solvsig() {
4119     solvsig_free($self);
4120   }
4121   %newobject Chksum;
4122   Chksum *Chksum() {
4123     return $self->htype ? (Chksum *)solv_chksum_create($self->htype) : 0;
4124   }
4125 #ifdef ENABLE_PGPVRFY
4126   %newobject verify;
4127   XSolvable *verify(Repo *repo, Chksum *chksum) {
4128     Id p = solvsig_verify($self, repo, chksum);
4129     return new_XSolvable(repo->pool, p);
4130   }
4131 #endif
4132 }
4133 #endif
4134
4135 %extend Alternative {
4136   static const int SOLVER_ALTERNATIVE_TYPE_RULE = SOLVER_ALTERNATIVE_TYPE_RULE;
4137   static const int SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = SOLVER_ALTERNATIVE_TYPE_RECOMMENDS;
4138   static const int SOLVER_ALTERNATIVE_TYPE_SUGGESTS = SOLVER_ALTERNATIVE_TYPE_SUGGESTS;
4139
4140   ~Alternative() {
4141     queue_free(&$self->choices);
4142     solv_free($self);
4143   }
4144   %newobject chosen;
4145   XSolvable * const chosen;
4146   %newobject rule;
4147   XRule * const rule;
4148   %newobject depsolvable;
4149   XSolvable * const depsolvable;
4150   %newobject dep;
4151   Dep * const dep;
4152   %{
4153     SWIGINTERN XSolvable *Alternative_chosen_get(Alternative *a) {
4154       return new_XSolvable(a->solv->pool, a->chosen_id);
4155     }
4156     SWIGINTERN XRule *Alternative_rule_get(Alternative *a) {
4157       return new_XRule(a->solv, a->rid);
4158     }
4159     SWIGINTERN XSolvable *Alternative_depsolvable_get(Alternative *a) {
4160       return new_XSolvable(a->solv->pool, a->from_id);
4161     }
4162     SWIGINTERN Dep *Alternative_dep_get(Alternative *a) {
4163       return new_Dep(a->solv->pool, a->dep_id);
4164     }
4165   %}
4166
4167   Queue choices_raw() {
4168     Queue r;
4169     queue_init_clone(&r, &$self->choices);
4170     return r;
4171   }
4172
4173   %typemap(out) Queue choices Queue2Array(XSolvable *, 1, new_XSolvable(arg1->solv->pool, id));
4174   Queue choices() {
4175     int i;
4176     Queue r;
4177     queue_init_clone(&r, &$self->choices);
4178     for (i = 0; i < r.count; i++)
4179       if (r.elements[i] < 0)
4180         r.elements[i] = -r.elements[i];
4181     return r;
4182   }
4183
4184 #if defined(SWIGPERL) || defined(SWIGTCL)
4185   %rename("str") __str__;
4186 #endif
4187   const char *__str__() {
4188     return solver_alternative2str($self->solv, $self->type, $self->type == SOLVER_ALTERNATIVE_TYPE_RULE ? $self->rid : $self->dep_id, $self->from_id);
4189   }
4190 }
4191
4192 #if defined(SWIGTCL)
4193 %init %{
4194   Tcl_Eval(interp,
4195 "proc solv::iter {varname iter body} {\n"\
4196 "  while 1 {\n"\
4197 "    set value [$iter __next__]\n"\
4198 "    if {$value eq \"NULL\"} { break }\n"\
4199 "    uplevel [list set $varname $value]\n"\
4200 "    set code [catch {uplevel $body} result]\n"\
4201 "    switch -exact -- $code {\n"\
4202 "      0 {}\n"\
4203 "      3 { return }\n"\
4204 "      4 {}\n"\
4205 "      default { return -code $code $result }\n"\
4206 "    }\n"\
4207 "  }\n"\
4208 "}\n"
4209   );
4210 %}
4211 #endif
4212