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