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