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