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
9 # %rename("to_s") string();
11 ##if defined(SWIGPYTHON)
12 # %rename("__str__") string();
19 %markfunc Pool "mark_Pool";
22 #if defined(SWIGPYTHON)
24 /* Check if is a list */
26 if (PyList_Check($input)) {
27 int size = PyList_Size($input);
29 for (i = 0; i < size; i++) {
30 PyObject *o = PyList_GetItem($input,i);
32 int e = SWIG_AsVal_int(o, &v);
34 SWIG_exception_fail(SWIG_ArgError(e), "list must contain only integers");
41 PyErr_SetString(PyExc_TypeError,"not a list");
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]));
55 %define Queue2Array(type, step, con) %{
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)
63 #define result resultx
66 PyList_SetItem(o, i, $result);
83 if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV)
84 SWIG_croak("Argument $argnum is not an array reference.");
85 av = (AV*)SvRV($input);
87 for (i = 0; i <= size; i++) {
88 SV **sv = av_fetch(av, i, 0);
90 int e = SWIG_AsVal_int(*sv, &v);
92 SWIG_croak("list must contain only integers");
98 # av_push(o, SvREFCNT_inc(SWIG_From_int($1.elements[i])));
99 # $result = newRV_noinc((SV*)o); argvi++;
101 %typemap(out) Queue {
103 if (argvi + $1.count + 1>= items) {
104 EXTEND(sp, items - (argvi + $1.count + 1) + 1);
106 for (i = 0; i < $1.count; i++)
107 ST(argvi++) = SvREFCNT_inc(SWIG_From_int($1.elements[i]));
111 %define Queue2Array(type, step, con) %{
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);
118 for (i = 0; i < cnt; i++, idp += step)
121 #define result resultx
124 SvREFCNT_inc(ST(argvi - 1));
134 %typemap(arginit) Queue {
137 %typemap(freearg) Queue {
141 #if defined(SWIGRUBY)
146 size = RARRAY($input)->len;
148 o = RARRAY($input)->ptr;
149 for (i = 0; i < size; i++, o++) {
151 int e = SWIG_AsVal_int(*o, &v);
153 SWIG_croak("list must contain only integers");
157 %typemap(out) Queue {
159 VALUE o = rb_ary_new2($1.count);
160 for (i = 0; i < $1.count; i++)
161 rb_ary_store(o, i, SWIG_From_int($1.elements[i]));
165 %typemap(arginit) Queue {
168 %typemap(freearg) Queue {
171 %define Queue2Array(type, step, con) %{
173 int cnt = $1.count / step;
174 Id *idp = $1.elements;
175 VALUE o = rb_ary_new2(cnt);
176 for (i = 0; i < cnt; i++, idp += step)
179 #define result resultx
182 rb_ary_store(o, i, $result);
194 #if defined(SWIGPERL)
196 # work around a swig bug
200 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv,pPerl)
202 # ifndef MULTIPLICITY
203 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv)
205 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(PERL_GET_THX, cv)
211 %define perliter(class)
214 my $i = ${##class##::ITERATORS}{$_[0]};
216 $_[1] == $i->[0] - 1 ? $i->[1] : undef;
218 $_[0]->__getitem__($_[1]);
221 sub class##::FETCHSIZE {
222 my $i = ${##class##::ITERATORS}{$_[0]};
224 ($i->[1] = $_[0]->__next__()) ? ++$i->[0] : 0;
234 #define SWIG_PERL_ITERATOR 0x80
236 SWIGRUNTIMEINLINE SV *
237 SWIG_Perl_NewArrayObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
238 SV *result = sv_newmortal();
239 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
244 sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
245 stash=SvSTASH(SvRV(obj));
246 if (flags & SWIG_POINTER_OWN) {
248 GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
250 gv_init(gv, stash, "OWNER", 5, FALSE);
252 hv_store_ent(hv, obj, newSViv(1), 0);
254 if (flags & SWIG_PERL_ITERATOR) {
256 GV *gv=*(GV**)hv_fetch(stash, "ITERATORS", 9, TRUE);
259 gv_init(gv, stash, "ITERATORS", 9, FALSE);
261 hv_store_ent(hv, obj, newRV_inc((SV *)av), 0);
263 sv_magic((SV *)array, (SV *)obj, 'P', Nullch, 0);
265 self=newRV_noinc((SV *)array);
266 sv_setsv(result, self);
267 SvREFCNT_dec((SV *)self);
268 sv_bless(result, stash);
270 sv_setref_pv(result, (char *) SWIG_Perl_TypeProxyName(t), ptr);
277 %typemap(out) Perlarray {
278 ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow); argvi++;
280 %typemap(out) Perliterator {
281 ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow | SWIG_PERL_ITERATOR); argvi++;
284 %typemap(out) Pool_solvable_iterator * = Perlarray;
285 %typemap(out) Pool_solvable_iterator * solvables_iter = Perliterator;
286 %typemap(out) Pool_repo_iterator * = Perlarray;
287 %typemap(out) Pool_repo_iterator * repos_iter = Perliterator;
288 %typemap(out) Repo_solvable_iterator * = Perlarray;
289 %typemap(out) Repo_solvable_iterator * solvables_iter = Perliterator;
290 %typemap(out) Dataiterator * = Perliterator;
296 #if defined(SWIGPYTHON)
297 typedef PyObject *AppObjectPtr;
298 %typemap(out) AppObjectPtr {
303 #if defined(SWIGPERL)
304 typedef SV *AppObjectPtr;
305 %typemap(in) AppObjectPtr {
306 $1 = SvROK($input) ? SvRV($input) : 0;
308 %typemap(out) AppObjectPtr {
309 $result = $1 ? newRV_inc($1) : newSV(0);
313 #if defined(SWIGRUBY)
314 typedef VALUE AppObjectPtr;
315 %typemap(in) AppObjectPtr {
318 %typemap(out) AppObjectPtr {
328 %include "typemaps.i"
332 #include "sys/stat.h"
337 #include "solverdebug.h"
338 #include "repo_solv.h"
341 #include "repo_rpmdb.h"
342 #include "repo_rpmmd.h"
343 #include "repo_write.h"
344 #include "repo_products.h"
345 #include "repo_susetags.h"
346 #include "repo_updateinfoxml.h"
347 #include "repo_deltainfoxml.h"
348 #include "repo_repomdxml.h"
349 #include "repo_content.h"
350 #include "sat_xfopen.h"
355 #define SOLVER_SOLUTION_ERASE -100
356 #define SOLVER_SOLUTION_REPLACE -101
357 #define SOLVER_SOLUTION_REPLACE_DOWNGRADE -102
358 #define SOLVER_SOLUTION_REPLACE_ARCHCHANGE -103
359 #define SOLVER_SOLUTION_REPLACE_VENDORCHANGE -104
361 typedef struct chksum Chksum;
363 typedef void *AppObjectPtr;
388 } Pool_solvable_iterator;
393 } Pool_repo_iterator;
398 } Repo_solvable_iterator;
438 Transaction *transaction;
446 typedef Dataiterator Datamatch;
451 %mixin Dataiterator "Enumerable";
452 %mixin Pool_solvable_iterator "Enumerable";
453 %mixin Pool_repo_iterator "Enumerable";
454 %mixin Repo_solvable_iterator "Enumerable";
462 %constant Id SOLVID_META;
463 %constant Id SOLVID_POS;
465 %constant int REL_EQ;
466 %constant int REL_GT;
467 %constant int REL_LT;
468 %constant int REL_ARCH;
496 # put before pool/repo so we can access the constructor
497 %nodefaultdtor Dataiterator;
498 typedef struct {} Dataiterator;
499 typedef struct {} Pool_solvable_iterator;
500 typedef struct {} Pool_repo_iterator;
501 typedef struct {} Repo_solvable_iterator;
503 %nodefaultctor Datamatch;
504 %nodefaultdtor Datamatch;
520 AppObjectPtr appdata;
525 typedef struct _Repo {
527 const char * const name;
530 int const nsolvables;
531 AppObjectPtr appdata;
534 %nodefaultctor Solver;
535 %nodefaultdtor Solver;
540 bool allowarchchange;
541 bool allowvendorchange;
544 bool noupdateprovide;
545 bool dosplitprovides;
546 bool dontinstallrecommended;
547 bool ignorealreadyrecommended;
548 bool dontshowinstalledrecommended;
550 bool distupgrade_removeunsupported;
554 typedef struct chksum {
557 %rename(xfopen) sat_xfopen;
558 %rename(xfopen_fd) sat_xfopen_fd;
559 %rename(xfopen_dup) sat_xfopen_dup;
560 %rename(xfclose) sat_xfclose;
561 %rename(xfileno) sat_xfileno;
563 FILE *sat_xfopen(const char *fn, const char *mode = 0);
564 FILE *sat_xfopen_fd(const char *fn, int fd, const char *mode = 0);
565 FILE *sat_xfopen_dup(const char *fn, int fd, const char *mode = 0);
566 int sat_xfclose(FILE *fp);
567 int sat_xfileno(FILE *fp);
570 SWIGINTERN int sat_xfclose(FILE *fp) {
573 SWIGINTERN int sat_xfileno(FILE *fp) {
576 SWIGINTERN FILE *sat_xfopen_dup(const char *fn, int fd, const char *mode) {
578 return fd == -1 ? 0 : sat_xfopen_fd(fn, fd, mode);
601 %nodefaultctor Transaction;
602 %nodefaultdtor Transaction;
608 Transaction * const transaction;
617 static const Id SOLVER_SOLVABLE = SOLVER_SOLVABLE;
618 static const Id SOLVER_SOLVABLE_NAME = SOLVER_SOLVABLE_NAME;
619 static const Id SOLVER_SOLVABLE_PROVIDES = SOLVER_SOLVABLE_PROVIDES;
620 static const Id SOLVER_SOLVABLE_ONE_OF = SOLVER_SOLVABLE_ONE_OF;
621 static const Id SOLVER_SOLVABLE_REPO = SOLVER_SOLVABLE_REPO;
622 static const Id SOLVER_SOLVABLE_ALL = SOLVER_SOLVABLE_ALL;
623 static const Id SOLVER_SELECTMASK = SOLVER_SELECTMASK;
624 static const Id SOLVER_NOOP = SOLVER_NOOP;
625 static const Id SOLVER_INSTALL = SOLVER_INSTALL;
626 static const Id SOLVER_ERASE = SOLVER_ERASE;
627 static const Id SOLVER_UPDATE = SOLVER_UPDATE;
628 static const Id SOLVER_WEAKENDEPS = SOLVER_WEAKENDEPS;
629 static const Id SOLVER_NOOBSOLETES = SOLVER_NOOBSOLETES;
630 static const Id SOLVER_LOCK = SOLVER_LOCK;
631 static const Id SOLVER_DISTUPGRADE = SOLVER_DISTUPGRADE;
632 static const Id SOLVER_VERIFY = SOLVER_VERIFY;
633 static const Id SOLVER_DROP_ORPHANED = SOLVER_DROP_ORPHANED;
634 static const Id SOLVER_USERINSTALLED = SOLVER_USERINSTALLED;
635 static const Id SOLVER_JOBMASK = SOLVER_JOBMASK;
636 static const Id SOLVER_WEAK = SOLVER_WEAK;
637 static const Id SOLVER_ESSENTIAL = SOLVER_ESSENTIAL;
638 static const Id SOLVER_CLEANDEPS = SOLVER_CLEANDEPS;
639 static const Id SOLVER_SETEV = SOLVER_SETEV;
640 static const Id SOLVER_SETEVR = SOLVER_SETEVR;
641 static const Id SOLVER_SETARCH = SOLVER_SETARCH;
642 static const Id SOLVER_SETVENDOR = SOLVER_SETVENDOR;
643 static const Id SOLVER_SETREPO = SOLVER_SETREPO;
644 static const Id SOLVER_NOAUTOSET = SOLVER_NOAUTOSET;
645 static const Id SOLVER_SETMASK = SOLVER_SETMASK;
647 Job(Pool *pool, Id how, Id what) {
648 Job *job = sat_calloc(1, sizeof(*job));
656 return pool_job2str($self->pool, $self->how, $self->what, 0);
659 Queue solvableids() {
660 Pool *pool = $self->pool;
664 how = $self->how & SOLVER_SELECTMASK;
665 FOR_JOB_SELECT(p, pp, how, $self->what)
669 %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
670 %newobject solvables;
672 return Job_solvableids($self);
678 return (Chksum *)sat_chksum_create(type);
680 Chksum(Id type, const char *hex) {
681 unsigned char buf[64];
682 int l = sat_chksum_len(type);
685 if (sat_hex2bin(&hex, buf, sizeof(buf)) != l || hex[0])
687 return (Chksum *)sat_chksum_create_from_bin(type, buf);
690 sat_chksum_free($self, 0);
694 SWIGINTERN Id Chksum_type_get(Chksum *chksum) {
695 return sat_chksum_get_type(chksum);
698 void add(const char *str) {
699 sat_chksum_add($self, str, strlen((char *)str));
701 void add_fp(FILE *fp) {
704 while ((l = fread(buf, 1, sizeof(buf), fp)) > 0)
705 sat_chksum_add($self, buf, l);
706 rewind(fp); /* convenience */
708 void add_fd(int fd) {
711 while ((l = read(fd, buf, sizeof(buf))) > 0)
712 sat_chksum_add($self, buf, l);
713 lseek(fd, 0, 0); /* convenience */
715 void add_stat(const char *filename) {
717 if (stat(filename, &stb))
718 memset(&stb, 0, sizeof(stb));
719 sat_chksum_add($self, &stb.st_dev, sizeof(stb.st_dev));
720 sat_chksum_add($self, &stb.st_ino, sizeof(stb.st_ino));
721 sat_chksum_add($self, &stb.st_size, sizeof(stb.st_size));
722 sat_chksum_add($self, &stb.st_mtime, sizeof(stb.st_mtime));
724 bool matches(Chksum *othersum) {
726 const unsigned char *b, *bo;
729 if (sat_chksum_get_type($self) != sat_chksum_get_type(othersum))
731 b = sat_chksum_get($self, &l);
732 bo = sat_chksum_get(othersum, 0);
733 return memcmp(b, bo, l) == 0;
737 const unsigned char *b;
738 b = sat_chksum_get($self, &l);
739 return cdata_void((void *)b, l);
744 const unsigned char *b;
747 b = sat_chksum_get($self, &l);
748 ret = sat_malloc(2 * l + 1);
749 sat_bin2hex(b, l, ret);
756 Pool *pool = pool_create();
761 void set_debuglevel(int level) {
762 pool_setdebuglevel($self, level);
764 #if defined(SWIGPYTHON)
766 SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
767 XRepodata *xd = new_XRepodata(data->repo, data - data->repo->repodata);
768 PyObject *args = Py_BuildValue("(O)", SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_POINTER_OWN | 0));
769 PyObject *result = PyEval_CallObject((PyObject *)d, args);
774 return 0; /* exception */
775 ecode = SWIG_AsVal_int(result, &vresult);
777 return SWIG_IsOK(ecode) ? vresult : 0;
780 void set_loadcallback(PyObject *callable) {
781 if ($self->loadcallback == loadcallback)
782 Py_DECREF($self->loadcallbackdata);
785 pool_setloadcallback($self, callable ? loadcallback : 0, callable);
788 #if defined(SWIGPERL)
791 SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
795 XRepodata *xd = new_XRepodata(data->repo, data - data->repo->repodata);
800 XPUSHs(SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_OWNER | SWIG_SHADOW));
802 count = perl_call_sv((SV *)d, G_EVAL|G_SCALAR);
813 void set_loadcallback(SV *callable) {
814 if ($self->loadcallback == loadcallback)
815 SvREFCNT_dec($self->loadcallbackdata);
817 SvREFCNT_inc(callable);
818 pool_setloadcallback($self, callable ? loadcallback : 0, callable);
822 #if defined(SWIGRUBY)
824 SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
825 XRepodata *xd = new_XRepodata(data->repo, data - data->repo->repodata);
826 VALUE callable = (VALUE)d;
827 VALUE rd = SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_POINTER_OWN | 0);
828 VALUE res = rb_funcall(callable, rb_intern("call"), 1, rd);
831 SWIGINTERN void mark_Pool(void *ptr) {
833 if (pool->loadcallback == loadcallback && pool->loadcallbackdata) {
834 VALUE callable = (VALUE)pool->loadcallbackdata;
835 rb_gc_mark(callable);
839 %typemap(in, numinputs=0) VALUE callable {
840 $1 = rb_block_given_p() ? rb_block_proc() : 0;
842 void set_loadcallback(VALUE callable) {
843 pool_setloadcallback($self, callable ? loadcallback : 0, (void *)callable);
848 Pool_set_loadcallback($self, 0);
851 Id str2id(const char *str, bool create=1) {
852 return str2id($self, str, create);
854 const char *id2str(Id id) {
855 return id2str($self, id);
857 const char *dep2str(Id id) {
858 return dep2str($self, id);
860 Id rel2id(Id name, Id evr, int flags, bool create=1) {
861 return rel2id($self, name, evr, flags, create);
863 Id id2langid(Id id, const char *lang, bool create=1) {
864 return pool_id2langid($self, id, lang, create);
866 void setarch(const char *arch) {
867 pool_setarch($self, arch);
869 Repo *add_repo(const char *name) {
870 return repo_create($self, name);
872 const char *lookup_str(Id entry, Id keyname) {
873 return pool_lookup_str($self, entry, keyname);
875 Id lookup_id(Id entry, Id keyname) {
876 return pool_lookup_id($self, entry, keyname);
878 unsigned int lookup_num(Id entry, Id keyname, unsigned int notfound = 0) {
879 return pool_lookup_num($self, entry, keyname, notfound);
881 bool lookup_void(Id entry, Id keyname) {
882 return pool_lookup_void($self, entry, keyname);
884 %newobject lookup_checksum;
885 Chksum *lookup_checksum(Id entry, Id keyname) {
887 const unsigned char *b = pool_lookup_bin_checksum($self, entry, keyname, &type);
888 return sat_chksum_create_from_bin(type, b);
891 %newobject Dataiterator;
892 Dataiterator *Dataiterator(Id p, Id key, const char *match, int flags) {
893 return new_Dataiterator($self, 0, p, key, match, flags);
895 const char *solvid2str(Id solvid) {
896 return solvid2str($self, solvid);
898 void addfileprovides() {
899 pool_addfileprovides($self);
901 Queue addfileprovides_ids() {
903 Id *addedfileprovides = 0;
905 pool_addfileprovides_ids($self, $self->installed, &addedfileprovides);
906 if (addedfileprovides) {
907 for (; *addedfileprovides; addedfileprovides++)
908 queue_push(&r, *addedfileprovides);
912 void createwhatprovides() {
913 pool_createwhatprovides($self);
916 %newobject solvables;
917 Pool_solvable_iterator * const solvables;
919 SWIGINTERN Pool_solvable_iterator * Pool_solvables_get(Pool *pool) {
920 return new_Pool_solvable_iterator(pool);
923 %newobject solvables_iter;
924 Pool_solvable_iterator * solvables_iter() {
925 return new_Pool_solvable_iterator($self);
929 Pool_repo_iterator * const repos;
931 SWIGINTERN Pool_repo_iterator * Pool_repos_get(Pool *pool) {
932 return new_Pool_repo_iterator(pool);
935 %newobject repos_iter;
936 Pool_repo_iterator * repos_iter() {
937 return new_Pool_repo_iterator($self);
942 SWIGINTERN void Pool_installed_set(Pool *pool, Repo *installed) {
943 pool_set_installed(pool, installed);
945 Repo *Pool_installed_get(Pool *pool) {
946 return pool->installed;
950 Queue providerids(Id dep) {
955 FOR_PROVIDES(p, pp, dep)
959 Queue matchprovidingids(const char *match, int flags) {
965 for (id = 1; id < pool->ss.nstrings; id++)
966 if (pool->whatprovides[id])
970 if (!datamatcher_init(&ma, match, flags)) {
971 for (id = 1; id < pool->ss.nstrings; id++)
972 if (pool->whatprovides[id] && datamatcher_match(&ma, id2str(pool, id)))
974 datamatcher_free(&ma);
980 Job *Job(Id how, Id what) {
981 return new_Job($self, how, what);
984 %typemap(out) Queue providers Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
985 %newobject providers;
986 Queue providers(Id dep) {
991 FOR_PROVIDES(p, pp, dep)
996 Id towhatprovides(Queue q) {
997 return pool_queuetowhatprovides($self, &q);
1000 %rename("isknownarch?") isknownarch;
1002 bool isknownarch(Id id) {
1004 if (!id || id == ID_EMPTY)
1006 if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
1008 if (pool->id2arch && (id > pool->lastarch || !pool->id2arch[id]))
1015 return solver_create($self);
1020 static const int REPO_REUSE_REPODATA = REPO_REUSE_REPODATA;
1021 static const int REPO_NO_INTERNALIZE = REPO_NO_INTERNALIZE;
1022 static const int REPO_LOCALPOOL = REPO_LOCALPOOL;
1023 static const int REPO_USE_LOADING = REPO_USE_LOADING;
1024 static const int REPO_EXTEND_SOLVABLES = REPO_EXTEND_SOLVABLES;
1025 static const int SOLV_ADD_NO_STUBS = SOLV_ADD_NO_STUBS; /* repo_solv */
1026 static const int SUSETAGS_RECORD_SHARES = SUSETAGS_RECORD_SHARES; /* repo_susetags */
1027 static const int SOLV_ADD_NO_STUBS = SOLV_ADD_NO_STUBS ; /* repo_solv */
1029 void free(bool reuseids = 0) {
1030 repo_free($self, reuseids);
1032 void empty(bool reuseids = 0) {
1033 repo_empty($self, reuseids);
1036 %rename("isempty?") isempty;
1039 return !$self->nsolvables;
1041 bool add_solv(const char *name, int flags = 0) {
1042 FILE *fp = fopen(name, "r");
1046 r = repo_add_solv_flags($self, fp, flags);
1050 bool add_solv(FILE *fp, int flags = 0) {
1051 return repo_add_solv_flags($self, fp, flags) == 0;
1053 bool add_products(const char *proddir, int flags = 0) {
1054 repo_add_products($self, proddir, 0, flags);
1057 bool add_rpmmd(FILE *fp, const char *language, int flags = 0) {
1058 repo_add_rpmmd($self, fp, language, flags);
1061 bool add_rpmdb(Repo *ref, int flags = 0) {
1062 repo_add_rpmdb($self, ref, 0, flags);
1065 Id add_rpm(const char *name, int flags = 0) {
1066 return repo_add_rpm($self, name, flags);
1068 bool add_susetags(FILE *fp, Id defvendor, const char *language, int flags = 0) {
1069 repo_add_susetags($self, fp, defvendor, language, flags);
1072 bool add_repomdxml(FILE *fp, int flags = 0) {
1073 repo_add_repomdxml($self, fp, flags);
1076 bool add_content(FILE *fp, int flags = 0) {
1077 repo_add_content($self, fp, flags);
1080 bool add_updateinfoxml(FILE *fp, int flags = 0) {
1081 repo_add_updateinfoxml($self, fp, flags);
1084 bool add_deltainfoxml(FILE *fp, int flags = 0) {
1085 repo_add_deltainfoxml($self, fp, flags);
1088 void internalize() {
1089 repo_internalize($self);
1091 const char *lookup_str(Id entry, Id keyname) {
1092 return repo_lookup_str($self, entry, keyname);
1094 Id lookup_id(Id entry, Id keyname) {
1095 return repo_lookup_id($self, entry, keyname);
1097 unsigned int lookup_num(Id entry, Id keyname, unsigned int notfound = 0) {
1098 return repo_lookup_num($self, entry, keyname, notfound);
1100 void write(FILE *fp) {
1101 repo_write($self, fp, repo_write_stdkeyfilter, 0, 0);
1103 # HACK, remove if no longer needed!
1104 bool write_first_repodata(FILE *fp, int flags = 0) {
1105 int oldnrepodata = $self->nrepodata;
1106 $self->nrepodata = 1;
1107 repo_write($self, fp, repo_write_stdkeyfilter, 0, 0);
1108 $self->nrepodata = oldnrepodata;
1112 %newobject Dataiterator;
1113 Dataiterator *Dataiterator(Id p, Id key, const char *match, int flags) {
1114 return new_Dataiterator($self->pool, $self, p, key, match, flags);
1119 SWIGINTERN Id Repo_id_get(Repo *repo) {
1120 return repo->repoid;
1123 Repo_solvable_iterator * const solvables;
1125 SWIGINTERN Repo_solvable_iterator * Repo_solvables_get(Repo *repo) {
1126 return new_Repo_solvable_iterator(repo);
1129 %newobject solvables_iter;
1130 Repo_solvable_iterator *solvables_iter() {
1131 return new_Repo_solvable_iterator($self);
1134 XRepodata *add_repodata(int flags = 0) {
1135 Repodata *rd = repo_add_repodata($self, flags);
1136 return new_XRepodata($self, rd - $self->repodata);
1139 void create_stubs() {
1141 if (!$self->nrepodata)
1143 data = $self->repodata + ($self->nrepodata - 1);
1144 if (data->state != REPODATA_STUB)
1145 repodata_create_stubs(data);
1148 %rename("iscontiguous?") iscontiguous;
1150 bool iscontiguous() {
1152 for (i = $self->start; i < $self->end; i++)
1153 if ($self->pool->solvables[i].repo != $self)
1157 XRepodata *first_repodata() {
1159 if (!$self->nrepodata)
1161 /* make sure all repodatas but the first are extensions */
1162 if ($self->repodata[0].loadcallback)
1164 for (i = 1; i < $self->nrepodata; i++)
1165 if (!$self->repodata[i].loadcallback)
1166 return 0; /* oops, not an extension */
1167 return new_XRepodata($self, 0);
1171 %extend Dataiterator {
1172 static const int SEARCH_STRING = SEARCH_STRING;
1173 static const int SEARCH_SUBSTRING = SEARCH_SUBSTRING;
1174 static const int SEARCH_GLOB = SEARCH_GLOB;
1175 static const int SEARCH_REGEX = SEARCH_REGEX;
1176 static const int SEARCH_NOCASE = SEARCH_NOCASE;
1177 static const int SEARCH_FILES = SEARCH_FILES;
1178 static const int SEARCH_COMPLETE_FILELIST = SEARCH_COMPLETE_FILELIST;
1180 Dataiterator(Pool *pool, Repo *repo, Id p, Id key, const char *match, int flags) {
1181 Dataiterator *di = sat_calloc(1, sizeof(*di));
1182 dataiterator_init(di, pool, repo, p, key, match, flags);
1186 dataiterator_free($self);
1189 #if defined(SWIGPYTHON)
1190 %newobject __iter__;
1191 Dataiterator *__iter__() {
1193 ndi = sat_calloc(1, sizeof(*ndi));
1194 dataiterator_init_clone(ndi, $self);
1197 %rename("next") __next__();
1198 %exception __next__ {
1201 PyErr_SetString(PyExc_StopIteration,"no more matches");
1208 perliter(solv::Dataiterator)
1211 %newobject __next__;
1212 Datamatch *__next__() {
1214 if (!dataiterator_step($self)) {
1217 ndi = sat_calloc(1, sizeof(*ndi));
1218 dataiterator_init_clone(ndi, $self);
1224 while ((d = Dataiterator___next__($self)) != 0) {
1225 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(d), SWIGTYPE_p_Datamatch, SWIG_POINTER_OWN | 0));
1229 void prepend_keyname(Id key) {
1230 dataiterator_prepend_keyname($self, key);
1232 void skip_solvable() {
1233 dataiterator_skip_solvable($self);
1239 dataiterator_free($self);
1242 %newobject solvable;
1243 XSolvable * const solvable;
1245 SWIGINTERN XSolvable *Datamatch_solvable_get(Dataiterator *di) {
1246 return new_XSolvable(di->pool, di->solvid);
1250 return $self->key->name;
1252 const char *key_idstr() {
1253 return id2str($self->pool, $self->key->name);
1256 return $self->key->type;
1258 const char *keytype_idstr() {
1259 return id2str($self->pool, $self->key->type);
1262 return $self->kv.id;
1264 const char *match_idstr() {
1265 return id2str($self->pool, $self->kv.id);
1267 const char *match_str() {
1268 return $self->kv.str;
1271 return $self->kv.num;
1274 return $self->kv.num2;
1276 void setpos_parent() {
1277 dataiterator_setpos_parent($self);
1281 %extend Pool_solvable_iterator {
1282 Pool_solvable_iterator(Pool *pool) {
1283 Pool_solvable_iterator *s;
1284 s = sat_calloc(1, sizeof(*s));
1288 #if defined(SWIGPYTHON)
1289 %newobject __iter__;
1290 Pool_solvable_iterator *__iter__() {
1291 Pool_solvable_iterator *s;
1292 s = sat_calloc(1, sizeof(*s));
1296 %rename("next") __next__();
1297 %exception __next__ {
1300 PyErr_SetString(PyExc_StopIteration,"no more matches");
1307 perliter(solv::Pool_solvable_iterator)
1309 %newobject __next__;
1310 XSolvable *__next__() {
1311 Pool *pool = $self->pool;
1313 if ($self->id >= pool->nsolvables)
1315 while (++$self->id < pool->nsolvables)
1316 if (pool->solvables[$self->id].repo)
1317 return new_XSolvable(pool, $self->id);
1323 while ((n = Pool_solvable_iterator___next__($self)) != 0) {
1324 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
1328 %newobject __getitem__;
1329 XSolvable *__getitem__(Id key) {
1330 Pool *pool = $self->pool;
1331 if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo)
1332 return new_XSolvable(pool, key);
1336 return $self->pool->nsolvables;
1340 %extend Pool_repo_iterator {
1341 Pool_repo_iterator(Pool *pool) {
1342 Pool_repo_iterator *s;
1343 s = sat_calloc(1, sizeof(*s));
1347 #if defined(SWIGPYTHON)
1348 %newobject __iter__;
1349 Pool_repo_iterator *__iter__() {
1350 Pool_repo_iterator *s;
1351 s = sat_calloc(1, sizeof(*s));
1355 %rename("next") __next__();
1356 %exception __next__ {
1359 PyErr_SetString(PyExc_StopIteration,"no more matches");
1364 %newobject __next__;
1366 Pool *pool = $self->pool;
1367 if ($self->id >= pool->nrepos + 1)
1369 while (++$self->id < pool->nrepos + 1) {
1370 Repo *r = pool_id2repo(pool, $self->id);
1379 while ((n = Pool_repo_iterator___next__($self)) != 0) {
1380 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p__Repo, SWIG_POINTER_OWN | 0));
1384 Repo *__getitem__(Id key) {
1385 Pool *pool = $self->pool;
1386 if (key > 0 && key < pool->nrepos + 1)
1387 return pool_id2repo(pool, key);
1391 return $self->pool->nrepos + 1;
1395 %extend Repo_solvable_iterator {
1396 Repo_solvable_iterator(Repo *repo) {
1397 Repo_solvable_iterator *s;
1398 s = sat_calloc(1, sizeof(*s));
1402 #if defined(SWIGPYTHON)
1403 %newobject __iter__;
1404 Repo_solvable_iterator *__iter__() {
1405 Repo_solvable_iterator *s;
1406 s = sat_calloc(1, sizeof(*s));
1410 %rename("next") __next__();
1411 %exception __next__ {
1414 PyErr_SetString(PyExc_StopIteration,"no more matches");
1419 %newobject __next__;
1420 XSolvable *__next__() {
1421 Repo *repo = $self->repo;
1422 Pool *pool = repo->pool;
1424 if (repo->start > 0 && $self->id < repo->start)
1425 $self->id = repo->start - 1;
1426 if ($self->id >= repo->end)
1428 while (++$self->id < repo->end)
1429 if (pool->solvables[$self->id].repo == repo)
1430 return new_XSolvable(pool, $self->id);
1436 while ((n = Repo_solvable_iterator___next__($self)) != 0) {
1437 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
1441 %newobject __getitem__;
1442 XSolvable *__getitem__(Id key) {
1443 Repo *repo = $self->repo;
1444 Pool *pool = repo->pool;
1445 if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo == repo)
1446 return new_XSolvable(pool, key);
1450 return $self->repo->pool->nsolvables;
1455 XId(Pool *pool, Id id) {
1459 s = sat_calloc(1, sizeof(*s));
1465 return dep2str($self->pool, $self->id);
1470 XSolvable(Pool *pool, Id id) {
1474 s = sat_calloc(1, sizeof(*s));
1480 return solvid2str($self->pool, $self->id);
1482 const char *lookup_str(Id keyname) {
1483 return pool_lookup_str($self->pool, $self->id, keyname);
1485 Id lookup_id(Id keyname) {
1486 return pool_lookup_id($self->pool, $self->id, keyname);
1488 unsigned int lookup_num(Id keyname, unsigned int notfound = 0) {
1489 return pool_lookup_num($self->pool, $self->id, keyname, notfound);
1491 bool lookup_void(Id keyname) {
1492 return pool_lookup_void($self->pool, $self->id, keyname);
1494 %newobject lookup_checksum;
1495 Chksum *lookup_checksum(Id keyname) {
1497 const unsigned char *b = pool_lookup_bin_checksum($self->pool, $self->id, keyname, &type);
1498 return sat_chksum_create_from_bin(type, b);
1500 const char *lookup_location(int *OUTPUT) {
1501 return solvable_get_location($self->pool->solvables + $self->id, OUTPUT);
1504 %rename("installable?") installable;
1506 bool installable() {
1507 return pool_installable($self->pool, pool_id2solvable($self->pool, $self->id));
1510 %rename("isinstalled?") isinstalled;
1512 bool isinstalled() {
1513 Pool *pool = $self->pool;
1514 return pool->installed && pool_id2solvable(pool, $self->id)->repo == pool->installed;
1517 const char * const name;
1519 SWIGINTERN const char *XSolvable_name_get(XSolvable *xs) {
1520 Pool *pool = xs->pool;
1521 return id2str(pool, pool->solvables[xs->id].name);
1526 SWIGINTERN Id XSolvable_nameid_get(XSolvable *xs) {
1527 return xs->pool->solvables[xs->id].name;
1530 const char * const evr;
1532 SWIGINTERN const char *XSolvable_evr_get(XSolvable *xs) {
1533 Pool *pool = xs->pool;
1534 return id2str(pool, pool->solvables[xs->id].evr);
1539 SWIGINTERN Id XSolvable_evrid_get(XSolvable *xs) {
1540 return xs->pool->solvables[xs->id].evr;
1543 const char * const arch;
1545 SWIGINTERN const char *XSolvable_arch_get(XSolvable *xs) {
1546 Pool *pool = xs->pool;
1547 return id2str(pool, pool->solvables[xs->id].arch);
1552 SWIGINTERN Id XSolvable_archid_get(XSolvable *xs) {
1553 return xs->pool->solvables[xs->id].arch;
1556 const char * const vendor;
1558 SWIGINTERN const char *XSolvable_vendor_get(XSolvable *xs) {
1559 Pool *pool = xs->pool;
1560 return id2str(pool, pool->solvables[xs->id].vendor);
1565 SWIGINTERN Id XSolvable_vendorid_get(XSolvable *xs) {
1566 return xs->pool->solvables[xs->id].vendor;
1571 SWIGINTERN Repo *XSolvable_repo_get(XSolvable *xs) {
1572 return xs->pool->solvables[xs->id].repo;
1578 Problem(Solver *solv, Id id) {
1580 p = sat_calloc(1, sizeof(*p));
1585 %newobject findproblemrule;
1586 XRule *findproblemrule() {
1587 Id r = solver_findproblemrule($self->solv, $self->id);
1588 return new_XRule($self->solv, r);
1590 %newobject findallproblemrules;
1591 %typemap(out) Queue findallproblemrules Queue2Array(XRule *, 1, new_XRule(arg1->solv, id));
1592 Queue findallproblemrules(int unfiltered=0) {
1593 Solver *solv = $self->solv;
1598 solver_findallproblemrules(solv, $self->id, &q);
1601 for (i = j = 0; i < q.count; i++)
1603 probr = q.elements[i];
1604 if ((probr >= solv->updaterules && probr < solv->updaterules_end) || (probr >= solv->jobrules && probr < solv->jobrules_end))
1606 q.elements[j++] = probr;
1609 queue_truncate(&q, j);
1613 int solution_count() {
1614 return solver_solution_count($self->solv, $self->id);
1616 %newobject solutions;
1617 %typemap(out) Queue solutions Queue2Array(Solution *, 1, new_Solution(arg1, id));
1622 cnt = solver_solution_count($self->solv, $self->id);
1623 for (i = 1; i <= cnt; i++)
1630 Solution(Problem *p, Id id) {
1632 s = sat_calloc(1, sizeof(*s));
1634 s->problemid = p->id;
1638 int element_count() {
1639 return solver_solutionelement_count($self->solv, $self->problemid, $self->id);
1642 %newobject elements;
1643 %typemap(out) Queue elements Queue2Array(Solutionelement *, 4, new_Solutionelement(arg1->solv, arg1->problemid, arg1->id, id, idp[1], idp[2], idp[3]));
1644 Queue elements(bool expandreplaces=0) {
1648 cnt = solver_solutionelement_count($self->solv, $self->problemid, $self->id);
1649 for (i = 1; i <= cnt; i++)
1652 solver_next_solutionelement($self->solv, $self->problemid, $self->id, i - 1, &p, &rp);
1654 type = rp ? SOLVER_SOLUTION_REPLACE : SOLVER_SOLUTION_ERASE;
1660 if (type == SOLVER_SOLUTION_REPLACE && expandreplaces) {
1661 int illegal = policy_is_illegal(self->solv, self->solv->pool->solvables + p, self->solv->pool->solvables + rp, 0);
1663 if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0) {
1664 queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_DOWNGRADE);
1665 queue_push2(&q, p, rp);
1667 if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0) {
1668 queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_ARCHCHANGE);
1669 queue_push2(&q, p, rp);
1671 if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0) {
1672 queue_push2(&q, i, SOLVER_SOLUTION_REPLACE_VENDORCHANGE);
1673 queue_push2(&q, p, rp);
1678 queue_push2(&q, i, type);
1679 queue_push2(&q, p, rp);
1685 %extend Solutionelement {
1686 Solutionelement(Solver *solv, Id problemid, Id solutionid, Id id, Id type, Id p, Id rp) {
1688 e = sat_calloc(1, sizeof(*e));
1690 e->problemid = problemid;
1701 if (p == SOLVER_SOLUTION_ERASE)
1706 else if (p == SOLVER_SOLUTION_REPLACE)
1711 else if (p == SOLVER_SOLUTION_REPLACE_DOWNGRADE)
1712 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);
1713 else if (p == SOLVER_SOLUTION_REPLACE_ARCHCHANGE)
1714 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);
1715 else if (p == SOLVER_SOLUTION_REPLACE_VENDORCHANGE)
1716 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);
1717 return solver_solutionelement2str($self->solv, p, rp);
1719 %newobject replaceelements;
1720 %typemap(out) Queue replaceelements Queue2Array(Solutionelement *, 1, new_Solutionelement(arg1->solv, arg1->problemid, arg1->solutionid, arg1->id, id, arg1->p, arg1->rp));
1721 Queue replaceelements() {
1726 if ($self->type != SOLVER_SOLUTION_REPLACE || $self->p <= 0 || $self->rp <= 0)
1729 illegal = policy_is_illegal($self->solv, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp, 0);
1730 if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
1731 queue_push(&q, SOLVER_SOLUTION_REPLACE_DOWNGRADE);
1732 if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
1733 queue_push(&q, SOLVER_SOLUTION_REPLACE_ARCHCHANGE);
1734 if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
1735 queue_push(&q, SOLVER_SOLUTION_REPLACE_VENDORCHANGE);
1737 queue_push(&q, $self->type);
1740 int illegalreplace() {
1741 if ($self->type != SOLVER_SOLUTION_REPLACE || $self->p <= 0 || $self->rp <= 0)
1743 return policy_is_illegal($self->solv, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp, 0);
1745 %newobject solvable;
1746 XSolvable * const solvable;
1747 %newobject replacement;
1748 XSolvable * const replacement;
1751 SWIGINTERN XSolvable *Solutionelement_solvable_get(Solutionelement *e) {
1752 return new_XSolvable(e->solv->pool, e->p);
1754 SWIGINTERN XSolvable *Solutionelement_replacement_get(Solutionelement *e) {
1755 return new_XSolvable(e->solv->pool, e->rp);
1757 SWIGINTERN int Solutionelement_jobidx_get(Solutionelement *e) {
1758 return (e->p - 1) / 2;
1763 if ($self->type == SOLVER_SOLUTION_INFARCH || $self->type == SOLVER_SOLUTION_DISTUPGRADE)
1764 return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE, $self->p);
1765 if ($self->type == SOLVER_SOLUTION_REPLACE || $self->type == SOLVER_SOLUTION_REPLACE_DOWNGRADE || $self->type == SOLVER_SOLUTION_REPLACE_ARCHCHANGE || $self->type == SOLVER_SOLUTION_REPLACE_VENDORCHANGE)
1766 return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE, $self->rp);
1767 if ($self->type == SOLVER_SOLUTION_ERASE)
1768 return new_Job($self->solv->pool, SOLVER_ERASE|SOLVER_SOLVABLE, $self->p);
1774 static const int SOLVER_RULE_UNKNOWN = SOLVER_RULE_UNKNOWN;
1775 static const int SOLVER_RULE_RPM = SOLVER_RULE_RPM;
1776 static const int SOLVER_RULE_RPM_NOT_INSTALLABLE = SOLVER_RULE_RPM_NOT_INSTALLABLE;
1777 static const int SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP = SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP;
1778 static const int SOLVER_RULE_RPM_PACKAGE_REQUIRES = SOLVER_RULE_RPM_PACKAGE_REQUIRES;
1779 static const int SOLVER_RULE_RPM_SELF_CONFLICT = SOLVER_RULE_RPM_SELF_CONFLICT;
1780 static const int SOLVER_RULE_RPM_PACKAGE_CONFLICT = SOLVER_RULE_RPM_PACKAGE_CONFLICT;
1781 static const int SOLVER_RULE_RPM_SAME_NAME = SOLVER_RULE_RPM_SAME_NAME;
1782 static const int SOLVER_RULE_RPM_PACKAGE_OBSOLETES = SOLVER_RULE_RPM_PACKAGE_OBSOLETES;
1783 static const int SOLVER_RULE_RPM_IMPLICIT_OBSOLETES = SOLVER_RULE_RPM_IMPLICIT_OBSOLETES;
1784 static const int SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES = SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES;
1785 static const int SOLVER_RULE_UPDATE = SOLVER_RULE_UPDATE;
1786 static const int SOLVER_RULE_FEATURE = SOLVER_RULE_FEATURE;
1787 static const int SOLVER_RULE_JOB = SOLVER_RULE_JOB;
1788 static const int SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
1789 static const int SOLVER_RULE_DISTUPGRADE = SOLVER_RULE_DISTUPGRADE;
1790 static const int SOLVER_RULE_INFARCH = SOLVER_RULE_INFARCH;
1791 static const int SOLVER_RULE_CHOICE = SOLVER_RULE_CHOICE;
1792 static const int SOLVER_RULE_LEARNT = SOLVER_RULE_LEARNT;
1794 static const int SOLVER_SOLUTION_JOB = SOLVER_SOLUTION_JOB;
1795 static const int SOLVER_SOLUTION_INFARCH = SOLVER_SOLUTION_INFARCH;
1796 static const int SOLVER_SOLUTION_DISTUPGRADE = SOLVER_SOLUTION_DISTUPGRADE;
1797 static const int SOLVER_SOLUTION_ERASE = SOLVER_SOLUTION_ERASE;
1798 static const int SOLVER_SOLUTION_REPLACE = SOLVER_SOLUTION_REPLACE;
1799 static const int SOLVER_SOLUTION_REPLACE_DOWNGRADE = SOLVER_SOLUTION_REPLACE_DOWNGRADE;
1800 static const int SOLVER_SOLUTION_REPLACE_ARCHCHANGE = SOLVER_SOLUTION_REPLACE_ARCHCHANGE;
1801 static const int SOLVER_SOLUTION_REPLACE_VENDORCHANGE = SOLVER_SOLUTION_REPLACE_VENDORCHANGE;
1803 static const int POLICY_ILLEGAL_DOWNGRADE = POLICY_ILLEGAL_DOWNGRADE;
1804 static const int POLICY_ILLEGAL_ARCHCHANGE = POLICY_ILLEGAL_ARCHCHANGE;
1805 static const int POLICY_ILLEGAL_VENDORCHANGE = POLICY_ILLEGAL_VENDORCHANGE;
1810 #if defined(SWIGPYTHON)
1812 def solve(self, jobs):
1814 for job in jobs: j += [job.how, job.what]
1815 return self.solve_helper(j)
1818 #if defined(SWIGPERL)
1820 sub solv::Solver::solve {
1821 my ($self, $jobs) = @_;
1822 my @j = map {($_->{'how'}, $_->{'what'})} @$jobs;
1823 return $self->solve_helper(\@j);
1827 #if defined(SWIGRUBY)
1830 "class Solv::Solver\n"
1831 " def solve(jobs)\n"
1833 " jobs.each do |j| ; jl << j.how << j.what ; end\n"
1834 " solve_helper(jl)\n"
1840 %typemap(out) Queue solve_helper Queue2Array(Problem *, 1, new_Problem(arg1, id));
1841 %newobject solve_helper;
1842 Queue solve_helper(Queue jobs) {
1846 solver_solve($self, &jobs);
1847 cnt = solver_problem_count($self);
1848 for (i = 1; i <= cnt; i++)
1852 %newobject transaction;
1853 Transaction *transaction() {
1855 t = sat_calloc(1, sizeof(*t));
1856 transaction_init_clone(t, &$self->trans);
1861 %extend Transaction {
1862 static const int SOLVER_TRANSACTION_IGNORE = SOLVER_TRANSACTION_IGNORE;
1863 static const int SOLVER_TRANSACTION_ERASE = SOLVER_TRANSACTION_ERASE;
1864 static const int SOLVER_TRANSACTION_REINSTALLED = SOLVER_TRANSACTION_REINSTALLED;
1865 static const int SOLVER_TRANSACTION_DOWNGRADED = SOLVER_TRANSACTION_DOWNGRADED;
1866 static const int SOLVER_TRANSACTION_CHANGED = SOLVER_TRANSACTION_CHANGED;
1867 static const int SOLVER_TRANSACTION_UPGRADED = SOLVER_TRANSACTION_UPGRADED;
1868 static const int SOLVER_TRANSACTION_OBSOLETED = SOLVER_TRANSACTION_OBSOLETED;
1869 static const int SOLVER_TRANSACTION_INSTALL = SOLVER_TRANSACTION_INSTALL;
1870 static const int SOLVER_TRANSACTION_REINSTALL = SOLVER_TRANSACTION_REINSTALL;
1871 static const int SOLVER_TRANSACTION_DOWNGRADE = SOLVER_TRANSACTION_DOWNGRADE;
1872 static const int SOLVER_TRANSACTION_CHANGE = SOLVER_TRANSACTION_CHANGE;
1873 static const int SOLVER_TRANSACTION_UPGRADE = SOLVER_TRANSACTION_UPGRADE;
1874 static const int SOLVER_TRANSACTION_OBSOLETES = SOLVER_TRANSACTION_OBSOLETES;
1875 static const int SOLVER_TRANSACTION_MULTIINSTALL = SOLVER_TRANSACTION_MULTIINSTALL;
1876 static const int SOLVER_TRANSACTION_MULTIREINSTALL = SOLVER_TRANSACTION_MULTIREINSTALL;
1877 static const int SOLVER_TRANSACTION_MAXTYPE = SOLVER_TRANSACTION_MAXTYPE;
1878 static const int SOLVER_TRANSACTION_SHOW_ACTIVE = SOLVER_TRANSACTION_SHOW_ACTIVE;
1879 static const int SOLVER_TRANSACTION_SHOW_ALL = SOLVER_TRANSACTION_SHOW_ALL;
1880 static const int SOLVER_TRANSACTION_SHOW_OBSOLETES = SOLVER_TRANSACTION_SHOW_OBSOLETES;
1881 static const int SOLVER_TRANSACTION_SHOW_MULTIINSTALL = SOLVER_TRANSACTION_SHOW_MULTIINSTALL;
1882 static const int SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = SOLVER_TRANSACTION_CHANGE_IS_REINSTALL;
1883 static const int SOLVER_TRANSACTION_MERGE_VENDORCHANGES = SOLVER_TRANSACTION_MERGE_VENDORCHANGES;
1884 static const int SOLVER_TRANSACTION_MERGE_ARCHCHANGES = SOLVER_TRANSACTION_MERGE_ARCHCHANGES;
1885 static const int SOLVER_TRANSACTION_RPM_ONLY = SOLVER_TRANSACTION_RPM_ONLY;
1886 static const int SOLVER_TRANSACTION_ARCHCHANGE = SOLVER_TRANSACTION_ARCHCHANGE;
1887 static const int SOLVER_TRANSACTION_VENDORCHANGE = SOLVER_TRANSACTION_VENDORCHANGE;
1888 static const int SOLVER_TRANSACTION_KEEP_ORDERDATA = SOLVER_TRANSACTION_KEEP_ORDERDATA;
1890 transaction_free($self);
1894 %rename("isempty?") isempty;
1897 return $self->steps.count == 0;
1900 %newobject othersolvable;
1901 XSolvable *othersolvable(XSolvable *s) {
1902 Id op = transaction_obs_pkg($self, s->id);
1903 return new_XSolvable($self->pool, op);
1906 %newobject allothersolvables;
1907 %typemap(out) Queue allothersolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1908 Queue allothersolvables(XSolvable *s) {
1911 transaction_all_obs_pkgs($self, s->id, &q);
1915 %typemap(out) Queue classify Queue2Array(TransactionClass *, 4, new_TransactionClass(arg1, arg2, id, idp[1], idp[2], idp[3]));
1916 %newobject classify;
1917 Queue classify(int mode = 0) {
1920 transaction_classify($self, mode, &q);
1924 %typemap(out) Queue newpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1925 %newobject newpackages;
1926 Queue newpackages() {
1930 cut = transaction_installedresult(self, &q);
1931 queue_truncate(&q, cut);
1935 %typemap(out) Queue keptpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1936 %newobject keptpackages;
1937 Queue keptpackages() {
1941 cut = transaction_installedresult(self, &q);
1943 queue_deleten(&q, 0, cut);
1947 %typemap(out) Queue steps Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1951 queue_init_clone(&q, &$self->steps);
1955 int steptype(XSolvable *s, int mode) {
1956 return transaction_type($self, s->id, mode);
1958 int calc_installsizechange() {
1959 return transaction_calc_installsizechange($self);
1961 void order(int flags) {
1962 transaction_order($self, flags);
1966 %extend TransactionClass {
1967 TransactionClass(Transaction *trans, int mode, Id type, int count, Id fromid, Id toid) {
1968 TransactionClass *cl = sat_calloc(1, sizeof(*cl));
1969 cl->transaction = trans;
1973 cl->fromid = fromid;
1977 %newobject solvables;
1978 %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->transaction->pool, id));
1982 transaction_classify_pkgs($self->transaction, $self->mode, $self->type, $self->fromid, $self->toid, &q);
1988 XRule(Solver *solv, Id id) {
1991 XRule *xr = sat_calloc(1, sizeof(*xr));
1997 Id type, source, target, dep;
1998 type = solver_ruleinfo($self->solv, $self->id, &source, &target, &dep);
1999 return new_Ruleinfo($self, type, source, target, dep);
2001 %typemap(out) Queue allinfos Queue2Array(Ruleinfo *, 4, new_Ruleinfo(arg1, id, idp[1], idp[2], idp[3]));
2002 %newobject allinfos;
2006 solver_allruleinfos($self->solv, $self->id, &q);
2012 Ruleinfo(XRule *r, Id type, Id source, Id target, Id dep) {
2013 Ruleinfo *ri = sat_calloc(1, sizeof(*ri));
2017 ri->source = source;
2018 ri->target = target;
2022 XSolvable * const solvable;
2023 XSolvable * const othersolvable;
2025 SWIGINTERN XSolvable *Ruleinfo_solvable_get(Ruleinfo *ri) {
2026 return new_XSolvable(ri->solv->pool, ri->source);
2028 SWIGINTERN XSolvable *Ruleinfo_othersolvable_get(Ruleinfo *ri) {
2029 return new_XSolvable(ri->solv->pool, ri->target);
2032 const char *problemstr() {
2033 return solver_problemruleinfo2str($self->solv, $self->type, $self->source, $self->target, $self->dep);
2038 XRepodata(Repo *repo, Id id) {
2039 XRepodata *xr = sat_calloc(1, sizeof(*xr));
2045 return repodata_new_handle($self->repo->repodata + $self->id);
2047 void set_id(Id solvid, Id keyname, Id id) {
2048 repodata_set_id($self->repo->repodata + $self->id, solvid, keyname, id);
2050 void set_str(Id solvid, Id keyname, const char *str) {
2051 repodata_set_str($self->repo->repodata + $self->id, solvid, keyname, str);
2053 void set_poolstr(Id solvid, Id keyname, const char *str) {
2054 repodata_set_poolstr($self->repo->repodata + $self->id, solvid, keyname, str);
2056 void add_idarray(Id solvid, Id keyname, Id id) {
2057 repodata_add_idarray($self->repo->repodata + $self->id, solvid, keyname, id);
2059 void add_flexarray(Id solvid, Id keyname, Id handle) {
2060 repodata_add_flexarray($self->repo->repodata + $self->id, solvid, keyname, handle);
2062 void set_checksum(Id solvid, Id keyname, Chksum *chksum) {
2063 const unsigned char *buf = sat_chksum_get(chksum, 0);
2065 repodata_set_bin_checksum($self->repo->repodata + $self->id, solvid, keyname, sat_chksum_get_type(chksum), buf);
2067 const char *lookup_str(Id solvid, Id keyname) {
2068 return repodata_lookup_str($self->repo->repodata + $self->id, solvid, keyname);
2070 Queue lookup_idarray(Id solvid, Id keyname) {
2073 repodata_lookup_idarray($self->repo->repodata + $self->id, solvid, keyname, &r);
2076 %newobject lookup_checksum;
2077 Chksum *lookup_checksum(Id solvid, Id keyname) {
2079 const unsigned char *b = repodata_lookup_bin_checksum($self->repo->repodata + $self->id, solvid, keyname, &type);
2080 return sat_chksum_create_from_bin(type, b);
2082 void internalize() {
2083 repodata_internalize($self->repo->repodata + $self->id);
2085 void create_stubs() {
2086 repodata_create_stubs($self->repo->repodata + $self->id);
2088 void write(FILE *fp) {
2089 repodata_write($self->repo->repodata + $self->id, fp, repo_write_stdkeyfilter, 0);
2091 bool add_solv(FILE *fp, int flags = 0) {
2092 Repodata *data = $self->repo->repodata + $self->id;
2093 int r, oldstate = data->state;
2094 data->state = REPODATA_LOADING;
2095 r = repo_add_solv_flags(data->repo, fp, flags | REPO_USE_LOADING);
2097 data->state = oldstate;
2100 void extend_to_repo() {
2101 Repodata *data = $self->repo->repodata + $self->id;
2102 repodata_extend_block(data, data->repo->start, data->repo->end - data->repo->start);