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();
18 #if defined(SWIGPYTHON)
20 /* Check if is a list */
22 if (PyList_Check($input)) {
23 int size = PyList_Size($input);
25 for (i = 0; i < size; i++) {
26 PyObject *o = PyList_GetItem($input,i);
28 int e = SWIG_AsVal_int(o, &v);
30 SWIG_exception_fail(SWIG_ArgError(e), "list must contain only integers");
37 PyErr_SetString(PyExc_TypeError,"not a list");
44 PyObject *o = PyList_New($1.count);
45 for (i = 0; i < $1.count; i++)
46 PyList_SetItem(o, i, SWIG_From_int($1.elements[i]));
51 %define Queue2Array(type, step, con) %{
53 int cnt = $1.count / step;
54 Id *idp = $1.elements;
55 PyObject *o = PyList_New(cnt);
56 for (i = 0; i < cnt; i++, idp += step)
59 #define result resultx
62 PyList_SetItem(o, i, $result);
79 if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV)
80 SWIG_croak("Argument $argnum is not an array reference.");
81 av = (AV*)SvRV($input);
83 for (i = 0; i <= size; i++) {
84 SV **sv = av_fetch(av, i, 0);
86 int e = SWIG_AsVal_int(*sv, &v);
88 SWIG_croak("list must contain only integers");
94 # av_push(o, SvREFCNT_inc(SWIG_From_int($1.elements[i])));
95 # $result = newRV_noinc((SV*)o); argvi++;
99 if (argvi + $1.count + 1>= items) {
100 EXTEND(sp, items - (argvi + $1.count + 1) + 1);
102 for (i = 0; i < $1.count; i++)
103 ST(argvi++) = SvREFCNT_inc(SWIG_From_int($1.elements[i]));
107 %define Queue2Array(type, step, con) %{
109 int cnt = $1.count / step;
110 Id *idp = $1.elements;
111 if (argvi + cnt + 1 >= items) {
112 EXTEND(sp, items - (argvi + cnt + 1) + 1);
114 for (i = 0; i < cnt; i++, idp += step)
117 #define result resultx
120 SvREFCNT_inc(ST(argvi - 1));
130 %typemap(arginit) Queue {
133 %typemap(freearg) Queue {
137 #if defined(SWIGRUBY)
142 size = RARRAY($input)->len;
144 o = RARRAY($input)->ptr;
145 for (i = 0; i < size; i++, o++) {
147 int e = SWIG_AsVal_int(*o, &v);
149 SWIG_croak("list must contain only integers");
153 %typemap(out) Queue {
155 VALUE o = rb_ary_new2($1.count);
156 for (i = 0; i < $1.count; i++)
157 rb_ary_store(o, i, SWIG_From_int($1.elements[i]));
161 %typemap(arginit) Queue {
164 %typemap(freearg) Queue {
167 %define Queue2Array(type, step, con) %{
169 int cnt = $1.count / step;
170 Id *idp = $1.elements;
171 VALUE o = rb_ary_new2(cnt);
172 for (i = 0; i < cnt; i++, idp += step)
175 #define result resultx
178 rb_ary_store(o, i, $result);
190 #if defined(SWIGPERL)
192 # work around a swig bug
196 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv,pPerl)
198 # ifndef MULTIPLICITY
199 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(cv)
201 # define SWIG_CALLXS(_name) TOPMARK=MARK-PL_stack_base;_name(PERL_GET_THX, cv)
207 %define perliter(class)
210 my $i = ${##class##::ITERATORS}{$_[0]};
212 $_[1] == $i->[0] - 1 ? $i->[1] : undef;
214 $_[0]->__getitem__($_[1]);
217 sub class##::FETCHSIZE {
218 my $i = ${##class##::ITERATORS}{$_[0]};
220 ($i->[1] = $_[0]->__next__()) ? ++$i->[0] : 0;
230 #define SWIG_PERL_ITERATOR 0x80
232 SWIGRUNTIMEINLINE SV *
233 SWIG_Perl_NewArrayObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
234 SV *result = sv_newmortal();
235 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
240 sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
241 stash=SvSTASH(SvRV(obj));
242 if (flags & SWIG_POINTER_OWN) {
244 GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
246 gv_init(gv, stash, "OWNER", 5, FALSE);
248 hv_store_ent(hv, obj, newSViv(1), 0);
250 if (flags & SWIG_PERL_ITERATOR) {
252 GV *gv=*(GV**)hv_fetch(stash, "ITERATORS", 9, TRUE);
255 gv_init(gv, stash, "ITERATORS", 9, FALSE);
257 hv_store_ent(hv, obj, newRV_inc((SV *)av), 0);
259 sv_magic((SV *)array, (SV *)obj, 'P', Nullch, 0);
261 self=newRV_noinc((SV *)array);
262 sv_setsv(result, self);
263 SvREFCNT_dec((SV *)self);
264 sv_bless(result, stash);
266 sv_setref_pv(result, (char *) SWIG_Perl_TypeProxyName(t), ptr);
273 %typemap(out) Perlarray {
274 ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow); argvi++;
276 %typemap(out) Perliterator {
277 ST(argvi) = SWIG_Perl_NewArrayObj(SWIG_PERL_OBJECT_CALL SWIG_as_voidptr(result), $1_descriptor, $owner | $shadow | SWIG_PERL_ITERATOR); argvi++;
280 %typemap(out) Pool_solvable_iterator * = Perlarray;
281 %typemap(out) Pool_solvable_iterator * solvables_iter = Perliterator;
282 %typemap(out) Pool_repo_iterator * = Perlarray;
283 %typemap(out) Pool_repo_iterator * repos_iter = Perliterator;
284 %typemap(out) Repo_solvable_iterator * = Perlarray;
285 %typemap(out) Repo_solvable_iterator * solvables_iter = Perliterator;
286 %typemap(out) Dataiterator * = Perliterator;
292 #if defined(SWIGPYTHON)
293 typedef PyObject *AppObjectPtr;
294 %typemap(out) AppObjectPtr {
299 #if defined(SWIGPERL)
300 typedef SV *AppObjectPtr;
301 %typemap(in) AppObjectPtr {
302 $1 = SvROK($input) ? SvRV($input) : 0;
304 %typemap(out) AppObjectPtr {
305 $result = $1 ? newRV_inc($1) : newSV(0);
309 #if defined(SWIGRUBY)
310 typedef VALUE AppObjectPtr;
311 %typemap(in) AppObjectPtr {
314 %typemap(out) AppObjectPtr {
324 %include "typemaps.i"
328 #include "sys/stat.h"
333 #include "solverdebug.h"
334 #include "repo_solv.h"
337 #include "repo_rpmdb.h"
338 #include "repo_rpmmd.h"
339 #include "repo_write.h"
340 #include "repo_products.h"
341 #include "repo_susetags.h"
342 #include "repo_updateinfoxml.h"
343 #include "repo_deltainfoxml.h"
344 #include "repo_repomdxml.h"
345 #include "repo_content.h"
346 #include "sat_xfopen.h"
351 #define SOLVER_SOLUTION_ERASE -100
352 #define SOLVER_SOLUTION_REPLACE -101
353 typedef struct chksum Chksum;
355 typedef void *AppObjectPtr;
380 } Pool_solvable_iterator;
385 } Pool_repo_iterator;
390 } Repo_solvable_iterator;
429 typedef Dataiterator Datamatch;
434 %mixin Dataiterator "Enumerable";
435 %mixin Pool_solvable_iterator "Enumerable";
436 %mixin Pool_repo_iterator "Enumerable";
437 %mixin Repo_solvable_iterator "Enumerable";
445 %constant Id SOLVID_META;
446 %constant Id SOLVID_POS;
448 %constant int REL_EQ;
449 %constant int REL_GT;
450 %constant int REL_LT;
451 %constant int REL_ARCH;
479 # put before pool/repo so we can access the constructor
480 %nodefaultdtor Dataiterator;
481 typedef struct {} Dataiterator;
482 typedef struct {} Pool_solvable_iterator;
483 typedef struct {} Pool_repo_iterator;
484 typedef struct {} Repo_solvable_iterator;
486 %nodefaultctor Datamatch;
487 %nodefaultdtor Datamatch;
503 AppObjectPtr appdata;
508 typedef struct _Repo {
510 const char * const name;
513 int const nsolvables;
514 AppObjectPtr appdata;
517 %nodefaultctor Solver;
518 %nodefaultdtor Solver;
523 bool allowarchchange;
524 bool allowvendorchange;
527 bool noupdateprovide;
528 bool dosplitprovides;
529 bool dontinstallrecommended;
530 bool ignorealreadyrecommended;
531 bool dontshowinstalledrecommended;
533 bool distupgrade_removeunsupported;
537 typedef struct chksum {
540 %rename(xfopen) sat_xfopen;
541 %rename(xfopen_fd) sat_xfopen_fd;
542 %rename(xfopen_dup) sat_xfopen_dup;
543 %rename(xfclose) sat_xfclose;
544 %rename(xfileno) sat_xfileno;
546 FILE *sat_xfopen(const char *fn, const char *mode = 0);
547 FILE *sat_xfopen_fd(const char *fn, int fd, const char *mode = 0);
548 FILE *sat_xfopen_dup(const char *fn, int fd, const char *mode = 0);
549 int sat_xfclose(FILE *fp);
550 int sat_xfileno(FILE *fp);
553 SWIGINTERN int sat_xfclose(FILE *fp) {
556 SWIGINTERN int sat_xfileno(FILE *fp) {
559 SWIGINTERN FILE *sat_xfopen_dup(const char *fn, int fd, const char *mode) {
561 return fd == -1 ? 0 : sat_xfopen_fd(fn, fd, mode);
584 %nodefaultctor Transaction;
585 %nodefaultdtor Transaction;
593 static const Id SOLVER_SOLVABLE = SOLVER_SOLVABLE;
594 static const Id SOLVER_SOLVABLE_NAME = SOLVER_SOLVABLE_NAME;
595 static const Id SOLVER_SOLVABLE_PROVIDES = SOLVER_SOLVABLE_PROVIDES;
596 static const Id SOLVER_SOLVABLE_ONE_OF = SOLVER_SOLVABLE_ONE_OF;
597 static const Id SOLVER_SOLVABLE_REPO = SOLVER_SOLVABLE_REPO;
598 static const Id SOLVER_SOLVABLE_ALL = SOLVER_SOLVABLE_ALL;
599 static const Id SOLVER_SELECTMASK = SOLVER_SELECTMASK;
600 static const Id SOLVER_NOOP = SOLVER_NOOP;
601 static const Id SOLVER_INSTALL = SOLVER_INSTALL;
602 static const Id SOLVER_ERASE = SOLVER_ERASE;
603 static const Id SOLVER_UPDATE = SOLVER_UPDATE;
604 static const Id SOLVER_WEAKENDEPS = SOLVER_WEAKENDEPS;
605 static const Id SOLVER_NOOBSOLETES = SOLVER_NOOBSOLETES;
606 static const Id SOLVER_LOCK = SOLVER_LOCK;
607 static const Id SOLVER_DISTUPGRADE = SOLVER_DISTUPGRADE;
608 static const Id SOLVER_VERIFY = SOLVER_VERIFY;
609 static const Id SOLVER_DROP_ORPHANED = SOLVER_DROP_ORPHANED;
610 static const Id SOLVER_USERINSTALLED = SOLVER_USERINSTALLED;
611 static const Id SOLVER_JOBMASK = SOLVER_JOBMASK;
612 static const Id SOLVER_WEAK = SOLVER_WEAK;
613 static const Id SOLVER_ESSENTIAL = SOLVER_ESSENTIAL;
614 static const Id SOLVER_CLEANDEPS = SOLVER_CLEANDEPS;
615 static const Id SOLVER_SETEV = SOLVER_SETEV;
616 static const Id SOLVER_SETEVR = SOLVER_SETEVR;
617 static const Id SOLVER_SETARCH = SOLVER_SETARCH;
618 static const Id SOLVER_SETVENDOR = SOLVER_SETVENDOR;
619 static const Id SOLVER_SETREPO = SOLVER_SETREPO;
620 static const Id SOLVER_NOAUTOSET = SOLVER_NOAUTOSET;
621 static const Id SOLVER_SETMASK = SOLVER_SETMASK;
623 Job(Pool *pool, Id how, Id what) {
624 Job *job = sat_calloc(1, sizeof(*job));
632 return pool_job2str($self->pool, $self->how, $self->what, 0);
635 Queue solvableids() {
636 Pool *pool = $self->pool;
640 how = $self->how & SOLVER_SELECTMASK;
641 FOR_JOB_SELECT(p, pp, how, $self->what)
645 %typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
646 %newobject solvables;
648 return Job_solvableids($self);
654 return (Chksum *)sat_chksum_create(type);
656 Chksum(Id type, const char *hex) {
657 unsigned char buf[64];
658 int l = sat_chksum_len(type);
661 if (sat_hex2bin(&hex, buf, sizeof(buf)) != l || hex[0])
663 return (Chksum *)sat_chksum_create_from_bin(type, buf);
666 sat_chksum_free($self, 0);
670 SWIGINTERN Id Chksum_type_get(Chksum *chksum) {
671 return sat_chksum_get_type(chksum);
674 void add(const char *str) {
675 sat_chksum_add($self, str, strlen((char *)str));
677 void add_fp(FILE *fp) {
680 while ((l = fread(buf, 1, sizeof(buf), fp)) > 0)
681 sat_chksum_add($self, buf, l);
682 rewind(fp); /* convenience */
684 void add_fd(int fd) {
687 while ((l = read(fd, buf, sizeof(buf))) > 0)
688 sat_chksum_add($self, buf, l);
689 lseek(fd, 0, 0); /* convenience */
691 void add_stat(const char *filename) {
693 if (stat(filename, &stb))
694 memset(&stb, 0, sizeof(stb));
695 sat_chksum_add($self, &stb.st_dev, sizeof(stb.st_dev));
696 sat_chksum_add($self, &stb.st_ino, sizeof(stb.st_ino));
697 sat_chksum_add($self, &stb.st_size, sizeof(stb.st_size));
698 sat_chksum_add($self, &stb.st_mtime, sizeof(stb.st_mtime));
700 bool matches(Chksum *othersum) {
702 const unsigned char *b, *bo;
705 if (sat_chksum_get_type($self) != sat_chksum_get_type(othersum))
707 b = sat_chksum_get($self, &l);
708 bo = sat_chksum_get(othersum, 0);
709 return memcmp(b, bo, l) == 0;
713 const unsigned char *b;
714 b = sat_chksum_get($self, &l);
715 return cdata_void((void *)b, l);
720 const unsigned char *b;
723 b = sat_chksum_get($self, &l);
724 ret = sat_malloc(2 * l + 1);
725 sat_bin2hex(b, l, ret);
734 Pool *pool = pool_create();
739 void set_debuglevel(int level) {
740 pool_setdebuglevel($self, level);
742 #if defined(SWIGPYTHON)
744 SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
745 XRepodata *xd = new_XRepodata(data->repo, data - data->repo->repodata);
746 PyObject *args = Py_BuildValue("(O)", SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_POINTER_OWN | 0));
747 PyObject *result = PyEval_CallObject((PyObject *)d, args);
752 return 0; /* exception */
753 ecode = SWIG_AsVal_int(result, &vresult);
755 return SWIG_IsOK(ecode) ? vresult : 0;
758 void set_loadcallback(PyObject *callable) {
759 if ($self->loadcallback == loadcallback)
760 Py_DECREF($self->loadcallbackdata);
763 pool_setloadcallback($self, callable ? loadcallback : 0, callable);
766 #if defined(SWIGPERL)
769 SWIGINTERN int loadcallback(Pool *pool, Repodata *data, void *d) {
773 XRepodata *xd = new_XRepodata(data->repo, data - data->repo->repodata);
778 XPUSHs(SWIG_NewPointerObj(SWIG_as_voidptr(xd), SWIGTYPE_p_XRepodata, SWIG_OWNER | SWIG_SHADOW));
780 count = perl_call_sv((SV *)d, G_EVAL|G_SCALAR);
791 void set_loadcallback(SV *callable) {
792 if ($self->loadcallback == loadcallback)
793 SvREFCNT_dec($self->loadcallbackdata);
795 SvREFCNT_inc(callable);
796 pool_setloadcallback($self, callable ? loadcallback : 0, callable);
801 #if defined(SWIGPYTHON) || defined(SWIGPERL)
802 Pool_set_loadcallback($self, 0);
806 Id str2id(const char *str, bool create=1) {
807 return str2id($self, str, create);
809 const char *id2str(Id id) {
810 return id2str($self, id);
812 const char *dep2str(Id id) {
813 return dep2str($self, id);
815 Id rel2id(Id name, Id evr, int flags, bool create=1) {
816 return rel2id($self, name, evr, flags, create);
818 Id id2langid(Id id, const char *lang, bool create=1) {
819 return pool_id2langid($self, id, lang, create);
821 void setarch(const char *arch) {
822 pool_setarch($self, arch);
824 Repo *add_repo(const char *name) {
825 return repo_create($self, name);
827 const char *lookup_str(Id entry, Id keyname) {
828 return pool_lookup_str($self, entry, keyname);
830 Id lookup_id(Id entry, Id keyname) {
831 return pool_lookup_id($self, entry, keyname);
833 unsigned int lookup_num(Id entry, Id keyname, unsigned int notfound = 0) {
834 return pool_lookup_num($self, entry, keyname, notfound);
836 bool lookup_void(Id entry, Id keyname) {
837 return pool_lookup_void($self, entry, keyname);
839 %newobject lookup_checksum;
840 Chksum *lookup_checksum(Id entry, Id keyname) {
842 const unsigned char *b = pool_lookup_bin_checksum($self, entry, keyname, &type);
843 return sat_chksum_create_from_bin(type, b);
846 %newobject Dataiterator;
847 Dataiterator *Dataiterator(Id p, Id key, const char *match, int flags) {
848 return new_Dataiterator($self, 0, p, key, match, flags);
850 const char *solvid2str(Id solvid) {
851 return solvid2str($self, solvid);
853 void addfileprovides() {
854 pool_addfileprovides($self);
856 Queue addfileprovides_ids() {
858 Id *addedfileprovides = 0;
860 pool_addfileprovides_ids($self, $self->installed, &addedfileprovides);
861 if (addedfileprovides) {
862 for (; *addedfileprovides; addedfileprovides++)
863 queue_push(&r, *addedfileprovides);
867 void createwhatprovides() {
868 pool_createwhatprovides($self);
871 %newobject solvables;
872 Pool_solvable_iterator * const solvables;
874 SWIGINTERN Pool_solvable_iterator * Pool_solvables_get(Pool *pool) {
875 return new_Pool_solvable_iterator(pool);
878 %newobject solvables_iter;
879 Pool_solvable_iterator * solvables_iter() {
880 return new_Pool_solvable_iterator($self);
884 Pool_repo_iterator * const repos;
886 SWIGINTERN Pool_repo_iterator * Pool_repos_get(Pool *pool) {
887 return new_Pool_repo_iterator(pool);
890 %newobject repos_iter;
891 Pool_repo_iterator * repos_iter() {
892 return new_Pool_repo_iterator($self);
897 SWIGINTERN void Pool_installed_set(Pool *pool, Repo *installed) {
898 pool_set_installed(pool, installed);
900 Repo *Pool_installed_get(Pool *pool) {
901 return pool->installed;
905 Queue providerids(Id dep) {
910 FOR_PROVIDES(p, pp, dep)
914 Queue matchprovidingids(const char *match, int flags) {
920 for (id = 1; id < pool->ss.nstrings; id++)
921 if (pool->whatprovides[id])
925 if (!datamatcher_init(&ma, match, flags)) {
926 for (id = 1; id < pool->ss.nstrings; id++)
927 if (pool->whatprovides[id] && datamatcher_match(&ma, id2str(pool, id)))
929 datamatcher_free(&ma);
935 Job *Job(Id how, Id what) {
936 return new_Job($self, how, what);
939 %typemap(out) Queue providers Queue2Array(XSolvable *, 1, new_XSolvable(arg1, id));
940 %newobject providers;
941 Queue providers(Id dep) {
946 FOR_PROVIDES(p, pp, dep)
951 Id towhatprovides(Queue q) {
952 return pool_queuetowhatprovides($self, &q);
954 bool isknownarch(Id id) {
956 if (!id || id == ID_EMPTY)
958 if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
960 if (pool->id2arch && (id > pool->lastarch || !pool->id2arch[id]))
967 return solver_create($self);
972 static const int REPO_REUSE_REPODATA = REPO_REUSE_REPODATA;
973 static const int REPO_NO_INTERNALIZE = REPO_NO_INTERNALIZE;
974 static const int REPO_LOCALPOOL = REPO_LOCALPOOL;
975 static const int REPO_USE_LOADING = REPO_USE_LOADING;
976 static const int REPO_EXTEND_SOLVABLES = REPO_EXTEND_SOLVABLES;
977 static const int SOLV_ADD_NO_STUBS = SOLV_ADD_NO_STUBS; /* repo_solv */
978 static const int SUSETAGS_RECORD_SHARES = SUSETAGS_RECORD_SHARES; /* repo_susetags */
979 static const int SOLV_ADD_NO_STUBS = SOLV_ADD_NO_STUBS ; /* repo_solv */
981 void free(bool reuseids = 0) {
982 repo_free($self, reuseids);
984 void empty(bool reuseids = 0) {
985 repo_empty($self, reuseids);
988 %rename("isempty?") isempty();
991 return !$self->nsolvables;
993 bool add_solv(const char *name, int flags = 0) {
994 FILE *fp = fopen(name, "r");
998 r = repo_add_solv_flags($self, fp, flags);
1002 bool add_solv(FILE *fp, int flags = 0) {
1003 return repo_add_solv_flags($self, fp, flags) == 0;
1005 bool add_products(const char *proddir, int flags = 0) {
1006 repo_add_products($self, proddir, 0, flags);
1009 bool add_rpmmd(FILE *fp, const char *language, int flags = 0) {
1010 repo_add_rpmmd($self, fp, language, flags);
1013 bool add_rpmdb(Repo *ref, int flags = 0) {
1014 repo_add_rpmdb($self, ref, 0, flags);
1017 Id add_rpm(const char *name, int flags = 0) {
1018 return repo_add_rpm($self, name, flags);
1020 bool add_susetags(FILE *fp, Id defvendor, const char *language, int flags = 0) {
1021 repo_add_susetags($self, fp, defvendor, language, flags);
1024 bool add_repomdxml(FILE *fp, int flags = 0) {
1025 repo_add_repomdxml($self, fp, flags);
1028 bool add_content(FILE *fp, int flags = 0) {
1029 repo_add_content($self, fp, flags);
1032 bool add_updateinfoxml(FILE *fp, int flags = 0) {
1033 repo_add_updateinfoxml($self, fp, flags);
1036 bool add_deltainfoxml(FILE *fp, int flags = 0) {
1037 repo_add_deltainfoxml($self, fp, flags);
1040 void internalize() {
1041 repo_internalize($self);
1043 const char *lookup_str(Id entry, Id keyname) {
1044 return repo_lookup_str($self, entry, keyname);
1046 Id lookup_id(Id entry, Id keyname) {
1047 return repo_lookup_id($self, entry, keyname);
1049 unsigned int lookup_num(Id entry, Id keyname, unsigned int notfound = 0) {
1050 return repo_lookup_num($self, entry, keyname, notfound);
1052 void write(FILE *fp) {
1053 repo_write($self, fp, repo_write_stdkeyfilter, 0, 0);
1055 # HACK, remove if no longer needed!
1056 bool write_first_repodata(FILE *fp, int flags = 0) {
1057 int oldnrepodata = $self->nrepodata;
1058 $self->nrepodata = 1;
1059 repo_write($self, fp, repo_write_stdkeyfilter, 0, 0);
1060 $self->nrepodata = oldnrepodata;
1064 %newobject Dataiterator;
1065 Dataiterator *Dataiterator(Id p, Id key, const char *match, int flags) {
1066 return new_Dataiterator($self->pool, $self, p, key, match, flags);
1071 SWIGINTERN Id Repo_id_get(Repo *repo) {
1072 return repo->repoid;
1075 Repo_solvable_iterator * const solvables;
1077 SWIGINTERN Repo_solvable_iterator * Repo_solvables_get(Repo *repo) {
1078 return new_Repo_solvable_iterator(repo);
1081 %newobject solvables_iter;
1082 Repo_solvable_iterator *solvables_iter() {
1083 return new_Repo_solvable_iterator($self);
1086 XRepodata *add_repodata(int flags = 0) {
1087 Repodata *rd = repo_add_repodata($self, flags);
1088 return new_XRepodata($self, rd - $self->repodata);
1091 void create_stubs() {
1093 if (!$self->nrepodata)
1095 data = $self->repodata + ($self->nrepodata - 1);
1096 if (data->state != REPODATA_STUB)
1097 repodata_create_stubs(data);
1100 %rename("iscontiguous?") iscontiguous();
1102 bool iscontiguous() {
1104 for (i = $self->start; i < $self->end; i++)
1105 if ($self->pool->solvables[i].repo != $self)
1109 XRepodata *first_repodata() {
1111 if (!$self->nrepodata)
1113 /* make sure all repodatas but the first are extensions */
1114 if ($self->repodata[0].loadcallback)
1116 for (i = 1; i < $self->nrepodata; i++)
1117 if (!$self->repodata[i].loadcallback)
1118 return 0; /* oops, not an extension */
1119 return new_XRepodata($self, 0);
1123 %extend Dataiterator {
1124 static const int SEARCH_STRING = SEARCH_STRING;
1125 static const int SEARCH_SUBSTRING = SEARCH_SUBSTRING;
1126 static const int SEARCH_GLOB = SEARCH_GLOB;
1127 static const int SEARCH_REGEX = SEARCH_REGEX;
1128 static const int SEARCH_NOCASE = SEARCH_NOCASE;
1129 static const int SEARCH_FILES = SEARCH_FILES;
1130 static const int SEARCH_COMPLETE_FILELIST = SEARCH_COMPLETE_FILELIST;
1132 Dataiterator(Pool *pool, Repo *repo, Id p, Id key, const char *match, int flags) {
1133 Dataiterator *di = sat_calloc(1, sizeof(*di));
1134 dataiterator_init(di, pool, repo, p, key, match, flags);
1138 dataiterator_free($self);
1141 #if defined(SWIGPYTHON)
1142 %newobject __iter__;
1143 Dataiterator *__iter__() {
1145 ndi = sat_calloc(1, sizeof(*ndi));
1146 dataiterator_init_clone(ndi, $self);
1149 %rename("next") __next__();
1150 %exception __next__ {
1153 PyErr_SetString(PyExc_StopIteration,"no more matches");
1160 perliter(solv::Dataiterator)
1163 %newobject __next__;
1164 Datamatch *__next__() {
1166 if (!dataiterator_step($self)) {
1169 ndi = sat_calloc(1, sizeof(*ndi));
1170 dataiterator_init_clone(ndi, $self);
1176 while ((d = Dataiterator___next__($self)) != 0) {
1177 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(d), SWIGTYPE_p_Datamatch, SWIG_POINTER_OWN | 0));
1181 void prepend_keyname(Id key) {
1182 dataiterator_prepend_keyname($self, key);
1184 void skip_solvable() {
1185 dataiterator_skip_solvable($self);
1191 dataiterator_free($self);
1194 %newobject solvable;
1195 XSolvable * const solvable;
1197 SWIGINTERN XSolvable *Datamatch_solvable_get(Dataiterator *di) {
1198 return new_XSolvable(di->pool, di->solvid);
1202 return $self->key->name;
1204 const char *key_idstr() {
1205 return id2str($self->pool, $self->key->name);
1208 return $self->key->type;
1210 const char *keytype_idstr() {
1211 return id2str($self->pool, $self->key->type);
1214 return $self->kv.id;
1216 const char *match_idstr() {
1217 return id2str($self->pool, $self->kv.id);
1219 const char *match_str() {
1220 return $self->kv.str;
1223 return $self->kv.num;
1226 return $self->kv.num2;
1228 void setpos_parent() {
1229 dataiterator_setpos_parent($self);
1233 %extend Pool_solvable_iterator {
1234 Pool_solvable_iterator(Pool *pool) {
1235 Pool_solvable_iterator *s;
1236 s = sat_calloc(1, sizeof(*s));
1240 #if defined(SWIGPYTHON)
1241 %newobject __iter__;
1242 Pool_solvable_iterator *__iter__() {
1243 Pool_solvable_iterator *s;
1244 s = sat_calloc(1, sizeof(*s));
1248 %rename("next") __next__();
1249 %exception __next__ {
1252 PyErr_SetString(PyExc_StopIteration,"no more matches");
1259 perliter(solv::Pool_solvable_iterator)
1261 %newobject __next__;
1262 XSolvable *__next__() {
1263 Pool *pool = $self->pool;
1265 if ($self->id >= pool->nsolvables)
1267 while (++$self->id < pool->nsolvables)
1268 if (pool->solvables[$self->id].repo)
1269 return new_XSolvable(pool, $self->id);
1275 while ((n = Pool_solvable_iterator___next__($self)) != 0) {
1276 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
1280 %newobject __getitem__;
1281 XSolvable *__getitem__(Id key) {
1282 Pool *pool = $self->pool;
1283 if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo)
1284 return new_XSolvable(pool, key);
1288 return $self->pool->nsolvables;
1292 %extend Pool_repo_iterator {
1293 Pool_repo_iterator(Pool *pool) {
1294 Pool_repo_iterator *s;
1295 s = sat_calloc(1, sizeof(*s));
1299 #if defined(SWIGPYTHON)
1300 %newobject __iter__;
1301 Pool_repo_iterator *__iter__() {
1302 Pool_repo_iterator *s;
1303 s = sat_calloc(1, sizeof(*s));
1307 %rename("next") __next__();
1308 %exception __next__ {
1311 PyErr_SetString(PyExc_StopIteration,"no more matches");
1316 %newobject __next__;
1318 Pool *pool = $self->pool;
1319 if ($self->id >= pool->nrepos + 1)
1321 while (++$self->id < pool->nrepos + 1) {
1322 Repo *r = pool_id2repo(pool, $self->id);
1331 while ((n = Pool_repo_iterator___next__($self)) != 0) {
1332 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p__Repo, SWIG_POINTER_OWN | 0));
1336 Repo *__getitem__(Id key) {
1337 Pool *pool = $self->pool;
1338 if (key > 0 && key < pool->nrepos + 1)
1339 return pool_id2repo(pool, key);
1343 return $self->pool->nrepos + 1;
1347 %extend Repo_solvable_iterator {
1348 Repo_solvable_iterator(Repo *repo) {
1349 Repo_solvable_iterator *s;
1350 s = sat_calloc(1, sizeof(*s));
1354 #if defined(SWIGPYTHON)
1355 %newobject __iter__;
1356 Repo_solvable_iterator *__iter__() {
1357 Repo_solvable_iterator *s;
1358 s = sat_calloc(1, sizeof(*s));
1362 %rename("next") __next__();
1363 %exception __next__ {
1366 PyErr_SetString(PyExc_StopIteration,"no more matches");
1371 %newobject __next__;
1372 XSolvable *__next__() {
1373 Repo *repo = $self->repo;
1374 Pool *pool = repo->pool;
1376 if (repo->start > 0 && $self->id < repo->start)
1377 $self->id = repo->start - 1;
1378 if ($self->id >= repo->end)
1380 while (++$self->id < repo->end)
1381 if (pool->solvables[$self->id].repo == repo)
1382 return new_XSolvable(pool, $self->id);
1388 while ((n = Repo_solvable_iterator___next__($self)) != 0) {
1389 rb_yield(SWIG_NewPointerObj(SWIG_as_voidptr(n), SWIGTYPE_p_XSolvable, SWIG_POINTER_OWN | 0));
1393 %newobject __getitem__;
1394 XSolvable *__getitem__(Id key) {
1395 Repo *repo = $self->repo;
1396 Pool *pool = repo->pool;
1397 if (key > 0 && key < pool->nsolvables && pool->solvables[key].repo == repo)
1398 return new_XSolvable(pool, key);
1402 return $self->repo->pool->nsolvables;
1407 XId(Pool *pool, Id id) {
1411 s = sat_calloc(1, sizeof(*s));
1417 return dep2str($self->pool, $self->id);
1422 XSolvable(Pool *pool, Id id) {
1426 s = sat_calloc(1, sizeof(*s));
1432 return solvid2str($self->pool, $self->id);
1434 const char *lookup_str(Id keyname) {
1435 return pool_lookup_str($self->pool, $self->id, keyname);
1437 Id lookup_id(Id keyname) {
1438 return pool_lookup_id($self->pool, $self->id, keyname);
1440 unsigned int lookup_num(Id keyname, unsigned int notfound = 0) {
1441 return pool_lookup_num($self->pool, $self->id, keyname, notfound);
1443 bool lookup_void(Id keyname) {
1444 return pool_lookup_void($self->pool, $self->id, keyname);
1446 %newobject lookup_checksum;
1447 Chksum *lookup_checksum(Id keyname) {
1449 const unsigned char *b = pool_lookup_bin_checksum($self->pool, $self->id, keyname, &type);
1450 return sat_chksum_create_from_bin(type, b);
1452 const char *lookup_location(int *OUTPUT) {
1453 return solvable_get_location($self->pool->solvables + $self->id, OUTPUT);
1456 %rename("installable?") installable();
1458 bool installable() {
1459 return pool_installable($self->pool, pool_id2solvable($self->pool, $self->id));
1461 bool isinstalled() {
1462 Pool *pool = $self->pool;
1463 return pool->installed && pool_id2solvable(pool, $self->id)->repo == pool->installed;
1466 const char * const name;
1468 SWIGINTERN const char *XSolvable_name_get(XSolvable *xs) {
1469 Pool *pool = xs->pool;
1470 return id2str(pool, pool->solvables[xs->id].name);
1475 SWIGINTERN Id XSolvable_nameid_get(XSolvable *xs) {
1476 return xs->pool->solvables[xs->id].name;
1479 const char * const evr;
1481 SWIGINTERN const char *XSolvable_evr_get(XSolvable *xs) {
1482 Pool *pool = xs->pool;
1483 return id2str(pool, pool->solvables[xs->id].evr);
1488 SWIGINTERN Id XSolvable_evrid_get(XSolvable *xs) {
1489 return xs->pool->solvables[xs->id].evr;
1492 const char * const arch;
1494 SWIGINTERN const char *XSolvable_arch_get(XSolvable *xs) {
1495 Pool *pool = xs->pool;
1496 return id2str(pool, pool->solvables[xs->id].arch);
1501 SWIGINTERN Id XSolvable_archid_get(XSolvable *xs) {
1502 return xs->pool->solvables[xs->id].arch;
1505 const char * const vendor;
1507 SWIGINTERN const char *XSolvable_vendor_get(XSolvable *xs) {
1508 Pool *pool = xs->pool;
1509 return id2str(pool, pool->solvables[xs->id].vendor);
1514 SWIGINTERN Id XSolvable_vendorid_get(XSolvable *xs) {
1515 return xs->pool->solvables[xs->id].vendor;
1520 SWIGINTERN Repo *XSolvable_repo_get(XSolvable *xs) {
1521 return xs->pool->solvables[xs->id].repo;
1527 Problem(Solver *solv, Id id) {
1529 p = sat_calloc(1, sizeof(*p));
1534 %newobject findproblemrule;
1535 XRule *findproblemrule() {
1536 Id r = solver_findproblemrule($self->solv, $self->id);
1537 return new_XRule($self->solv, r);
1539 %newobject findallproblemrules;
1540 %typemap(out) Queue findallproblemrules Queue2Array(XRule *, 1, new_XRule(arg1->solv, id));
1541 Queue findallproblemrules(int unfiltered=0) {
1542 Solver *solv = $self->solv;
1547 solver_findallproblemrules(solv, $self->id, &q);
1550 for (i = j = 0; i < q.count; i++)
1552 probr = q.elements[i];
1553 if ((probr >= solv->updaterules && probr < solv->updaterules_end) || (probr >= solv->jobrules && probr < solv->jobrules_end))
1555 q.elements[j++] = probr;
1558 queue_truncate(&q, j);
1562 int solution_count() {
1563 return solver_solution_count($self->solv, $self->id);
1565 %newobject solutions;
1566 %typemap(out) Queue solutions Queue2Array(Solution *, 1, new_Solution(arg1, id));
1571 cnt = solver_solution_count($self->solv, $self->id);
1572 for (i = 1; i <= cnt; i++)
1579 Solution(Problem *p, Id id) {
1581 s = sat_calloc(1, sizeof(*s));
1583 s->problemid = p->id;
1587 int element_count() {
1588 return solver_solutionelement_count($self->solv, $self->problemid, $self->id);
1590 %newobject elements;
1591 %typemap(out) Queue elements Queue2Array(Solutionelement *, 1, new_Solutionelement(arg1, id));
1596 cnt = solver_solution_count($self->solv, $self->id);
1597 for (i = 1; i <= cnt; i++)
1603 %extend Solutionelement {
1604 Solutionelement(Solution *s, Id id) {
1606 e = sat_calloc(1, sizeof(*e));
1608 e->problemid = s->problemid;
1609 e->solutionid = s->id;
1611 solver_next_solutionelement(e->solv, e->problemid, e->solutionid, e->id - 1, &e->p, &e->rp);
1613 e->type = e->rp ? SOLVER_SOLUTION_REPLACE : SOLVER_SOLUTION_ERASE;
1621 int illegalreplace() {
1622 if ($self->type != SOLVER_SOLUTION_REPLACE || $self->p <= 0 || $self->rp <= 0)
1624 return policy_is_illegal($self->solv, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp, 0);
1626 %newobject solvable;
1627 XSolvable * const solvable;
1628 %newobject replacement;
1629 XSolvable * const replacement;
1632 SWIGINTERN XSolvable *Solutionelement_solvable_get(Solutionelement *e) {
1633 return new_XSolvable(e->solv->pool, e->p);
1635 SWIGINTERN XSolvable *Solutionelement_replacement_get(Solutionelement *e) {
1636 return new_XSolvable(e->solv->pool, e->rp);
1638 SWIGINTERN int Solutionelement_jobidx_get(Solutionelement *e) {
1639 return (e->p - 1) / 2;
1644 if ($self->type == SOLVER_SOLUTION_INFARCH || $self->type == SOLVER_SOLUTION_DISTUPGRADE)
1645 return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE, $self->p);
1646 if ($self->type == SOLVER_SOLUTION_REPLACE)
1647 return new_Job($self->solv->pool, SOLVER_INSTALL|SOLVER_SOLVABLE, $self->rp);
1648 if ($self->type == SOLVER_SOLUTION_ERASE)
1649 return new_Job($self->solv->pool, SOLVER_ERASE|SOLVER_SOLVABLE, $self->p);
1655 static const int SOLVER_RULE_UNKNOWN = SOLVER_RULE_UNKNOWN;
1656 static const int SOLVER_RULE_RPM = SOLVER_RULE_RPM;
1657 static const int SOLVER_RULE_RPM_NOT_INSTALLABLE = SOLVER_RULE_RPM_NOT_INSTALLABLE;
1658 static const int SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP = SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP;
1659 static const int SOLVER_RULE_RPM_PACKAGE_REQUIRES = SOLVER_RULE_RPM_PACKAGE_REQUIRES;
1660 static const int SOLVER_RULE_RPM_SELF_CONFLICT = SOLVER_RULE_RPM_SELF_CONFLICT;
1661 static const int SOLVER_RULE_RPM_PACKAGE_CONFLICT = SOLVER_RULE_RPM_PACKAGE_CONFLICT;
1662 static const int SOLVER_RULE_RPM_SAME_NAME = SOLVER_RULE_RPM_SAME_NAME;
1663 static const int SOLVER_RULE_RPM_PACKAGE_OBSOLETES = SOLVER_RULE_RPM_PACKAGE_OBSOLETES;
1664 static const int SOLVER_RULE_RPM_IMPLICIT_OBSOLETES = SOLVER_RULE_RPM_IMPLICIT_OBSOLETES;
1665 static const int SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES = SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES;
1666 static const int SOLVER_RULE_UPDATE = SOLVER_RULE_UPDATE;
1667 static const int SOLVER_RULE_FEATURE = SOLVER_RULE_FEATURE;
1668 static const int SOLVER_RULE_JOB = SOLVER_RULE_JOB;
1669 static const int SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
1670 static const int SOLVER_RULE_DISTUPGRADE = SOLVER_RULE_DISTUPGRADE;
1671 static const int SOLVER_RULE_INFARCH = SOLVER_RULE_INFARCH;
1672 static const int SOLVER_RULE_CHOICE = SOLVER_RULE_CHOICE;
1673 static const int SOLVER_RULE_LEARNT = SOLVER_RULE_LEARNT;
1675 static const int SOLVER_SOLUTION_JOB = SOLVER_SOLUTION_JOB;
1676 static const int SOLVER_SOLUTION_INFARCH = SOLVER_SOLUTION_INFARCH;
1677 static const int SOLVER_SOLUTION_DISTUPGRADE = SOLVER_SOLUTION_DISTUPGRADE;
1678 static const int SOLVER_SOLUTION_ERASE = SOLVER_SOLUTION_ERASE;
1679 static const int SOLVER_SOLUTION_REPLACE = SOLVER_SOLUTION_REPLACE;
1681 static const int POLICY_ILLEGAL_DOWNGRADE = POLICY_ILLEGAL_DOWNGRADE;
1682 static const int POLICY_ILLEGAL_ARCHCHANGE = POLICY_ILLEGAL_ARCHCHANGE;
1683 static const int POLICY_ILLEGAL_VENDORCHANGE = POLICY_ILLEGAL_VENDORCHANGE;
1688 #if defined(SWIGPYTHON)
1690 def solve(self, jobs):
1692 for job in jobs: j += [job.how, job.what]
1693 return self.solve_helper(j)
1696 #if defined(SWIGPERL)
1698 sub solv::Solver::solve {
1699 my ($self, $jobs) = @_;
1700 my @j = map {($_->{'how'}, $_->{'what'})} @$jobs;
1701 return $self->solve_helper(\@j);
1705 #if defined(SWIGRUBY)
1708 "class Solv::Solver\n"
1709 " def solve(jobs)\n"
1711 " jobs.each do |j| ; jl << j.how << j.what ; end\n"
1712 " solve_helper(jl)\n"
1718 %typemap(out) Queue solve_helper Queue2Array(Problem *, 1, new_Problem(arg1, id));
1719 %newobject solve_helper;
1720 Queue solve_helper(Queue jobs) {
1724 solver_solve($self, &jobs);
1725 cnt = solver_problem_count($self);
1726 for (i = 1; i <= cnt; i++)
1730 %newobject transaction;
1731 Transaction *transaction() {
1733 t = sat_calloc(1, sizeof(*t));
1734 transaction_init_clone(t, &$self->trans);
1739 %extend Transaction {
1740 static const int SOLVER_TRANSACTION_IGNORE = SOLVER_TRANSACTION_IGNORE;
1741 static const int SOLVER_TRANSACTION_ERASE = SOLVER_TRANSACTION_ERASE;
1742 static const int SOLVER_TRANSACTION_REINSTALLED = SOLVER_TRANSACTION_REINSTALLED;
1743 static const int SOLVER_TRANSACTION_DOWNGRADED = SOLVER_TRANSACTION_DOWNGRADED;
1744 static const int SOLVER_TRANSACTION_CHANGED = SOLVER_TRANSACTION_CHANGED;
1745 static const int SOLVER_TRANSACTION_UPGRADED = SOLVER_TRANSACTION_UPGRADED;
1746 static const int SOLVER_TRANSACTION_OBSOLETED = SOLVER_TRANSACTION_OBSOLETED;
1747 static const int SOLVER_TRANSACTION_INSTALL = SOLVER_TRANSACTION_INSTALL;
1748 static const int SOLVER_TRANSACTION_REINSTALL = SOLVER_TRANSACTION_REINSTALL;
1749 static const int SOLVER_TRANSACTION_DOWNGRADE = SOLVER_TRANSACTION_DOWNGRADE;
1750 static const int SOLVER_TRANSACTION_CHANGE = SOLVER_TRANSACTION_CHANGE;
1751 static const int SOLVER_TRANSACTION_UPGRADE = SOLVER_TRANSACTION_UPGRADE;
1752 static const int SOLVER_TRANSACTION_OBSOLETES = SOLVER_TRANSACTION_OBSOLETES;
1753 static const int SOLVER_TRANSACTION_MULTIINSTALL = SOLVER_TRANSACTION_MULTIINSTALL;
1754 static const int SOLVER_TRANSACTION_MULTIREINSTALL = SOLVER_TRANSACTION_MULTIREINSTALL;
1755 static const int SOLVER_TRANSACTION_MAXTYPE = SOLVER_TRANSACTION_MAXTYPE;
1756 static const int SOLVER_TRANSACTION_SHOW_ACTIVE = SOLVER_TRANSACTION_SHOW_ACTIVE;
1757 static const int SOLVER_TRANSACTION_SHOW_ALL = SOLVER_TRANSACTION_SHOW_ALL;
1758 static const int SOLVER_TRANSACTION_SHOW_OBSOLETES = SOLVER_TRANSACTION_SHOW_OBSOLETES;
1759 static const int SOLVER_TRANSACTION_SHOW_MULTIINSTALL = SOLVER_TRANSACTION_SHOW_MULTIINSTALL;
1760 static const int SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = SOLVER_TRANSACTION_CHANGE_IS_REINSTALL;
1761 static const int SOLVER_TRANSACTION_MERGE_VENDORCHANGES = SOLVER_TRANSACTION_MERGE_VENDORCHANGES;
1762 static const int SOLVER_TRANSACTION_MERGE_ARCHCHANGES = SOLVER_TRANSACTION_MERGE_ARCHCHANGES;
1763 static const int SOLVER_TRANSACTION_RPM_ONLY = SOLVER_TRANSACTION_RPM_ONLY;
1764 static const int SOLVER_TRANSACTION_ARCHCHANGE = SOLVER_TRANSACTION_ARCHCHANGE;
1765 static const int SOLVER_TRANSACTION_VENDORCHANGE = SOLVER_TRANSACTION_VENDORCHANGE;
1766 static const int SOLVER_TRANSACTION_KEEP_ORDERDATA = SOLVER_TRANSACTION_KEEP_ORDERDATA;
1768 transaction_free($self);
1772 %rename("isempty?") isempty();
1775 return $self->steps.count == 0;
1777 Queue classify_helper(int mode) {
1780 transaction_classify($self, mode, &q);
1783 Queue classify_pkgs_helper(int mode, Id cl, Id from, Id to) {
1786 transaction_classify_pkgs($self, mode, cl, from, to, &q);
1789 %newobject othersolvable;
1790 XSolvable *othersolvable(XSolvable *s) {
1791 Id op = transaction_obs_pkg($self, s->id);
1792 return new_XSolvable($self->pool, op);
1794 #if defined(SWIGPYTHON)
1796 def classify(self, mode = 0):
1798 cr = self.classify_helper(mode)
1799 for type, cnt, fromid, toid in zip(*([iter(cr)] * 4)):
1800 if type != self.SOLVER_TRANSACTION_IGNORE:
1801 r.append([ type, [ self.pool.solvables[j] for j in self.classify_pkgs_helper(mode, type, fromid, toid) ], fromid, toid ])
1805 #if defined(SWIGPERL)
1807 sub solv::Transaction::classify {
1808 my ($self, $mode) = @_;
1810 my @r = $self->classify_helper($mode);
1813 my ($type, $cnt, $fromid, $toid) = splice(@r, 0, 4);
1814 next if $type == $solv::Transaction::SOLVER_TRANSACTION_IGNORE;
1815 push @res, [$type, [ map {$self->{'pool'}->{'solvables'}->[$_]} $self->classify_pkgs_helper($mode, $type, $fromid, $toid) ], $fromid, $toid];
1822 %typemap(out) Queue newpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1823 %newobject newpackages;
1824 Queue newpackages() {
1828 cut = transaction_installedresult(self, &q);
1829 queue_truncate(&q, cut);
1833 %typemap(out) Queue keptpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1834 %newobject keptpackages;
1835 Queue keptpackages() {
1839 cut = transaction_installedresult(self, &q);
1841 queue_deleten(&q, 0, cut);
1845 %typemap(out) Queue steps Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
1849 queue_init_clone(&q, &$self->steps);
1853 int steptype(XSolvable *s, int mode) {
1854 return transaction_type($self, s->id, mode);
1856 int calc_installsizechange() {
1857 return transaction_calc_installsizechange($self);
1859 void order(int flags) {
1860 transaction_order($self, flags);
1865 XRule(Solver *solv, Id id) {
1868 XRule *xr = sat_calloc(1, sizeof(*xr));
1874 Id type, source, target, dep;
1875 type = solver_ruleinfo($self->solv, $self->id, &source, &target, &dep);
1876 return new_Ruleinfo($self, type, source, target, dep);
1878 %typemap(out) Queue allinfos Queue2Array(Ruleinfo *, 4, new_Ruleinfo(arg1, id, idp[1], idp[2], idp[3]));
1879 %newobject allinfos;
1883 solver_allruleinfos($self->solv, $self->id, &q);
1889 Ruleinfo(XRule *r, Id type, Id source, Id target, Id dep) {
1890 Ruleinfo *ri = sat_calloc(1, sizeof(*ri));
1894 ri->source = source;
1895 ri->target = target;
1899 XSolvable * const solvable;
1900 XSolvable * const othersolvable;
1902 SWIGINTERN XSolvable *Ruleinfo_solvable_get(Ruleinfo *ri) {
1903 return new_XSolvable(ri->solv->pool, ri->source);
1905 SWIGINTERN XSolvable *Ruleinfo_othersolvable_get(Ruleinfo *ri) {
1906 return new_XSolvable(ri->solv->pool, ri->target);
1909 const char *problemstr() {
1910 return solver_problemruleinfo2str($self->solv, $self->type, $self->source, $self->target, $self->dep);
1915 XRepodata(Repo *repo, Id id) {
1916 XRepodata *xr = sat_calloc(1, sizeof(*xr));
1922 return repodata_new_handle($self->repo->repodata + $self->id);
1924 void set_id(Id solvid, Id keyname, Id id) {
1925 repodata_set_id($self->repo->repodata + $self->id, solvid, keyname, id);
1927 void set_str(Id solvid, Id keyname, const char *str) {
1928 repodata_set_str($self->repo->repodata + $self->id, solvid, keyname, str);
1930 void set_poolstr(Id solvid, Id keyname, const char *str) {
1931 repodata_set_poolstr($self->repo->repodata + $self->id, solvid, keyname, str);
1933 void add_idarray(Id solvid, Id keyname, Id id) {
1934 repodata_add_idarray($self->repo->repodata + $self->id, solvid, keyname, id);
1936 void add_flexarray(Id solvid, Id keyname, Id handle) {
1937 repodata_add_flexarray($self->repo->repodata + $self->id, solvid, keyname, handle);
1939 void set_checksum(Id solvid, Id keyname, Chksum *chksum) {
1940 const unsigned char *buf = sat_chksum_get(chksum, 0);
1942 repodata_set_bin_checksum($self->repo->repodata + $self->id, solvid, keyname, sat_chksum_get_type(chksum), buf);
1944 const char *lookup_str(Id solvid, Id keyname) {
1945 return repodata_lookup_str($self->repo->repodata + $self->id, solvid, keyname);
1947 Queue lookup_idarray(Id solvid, Id keyname) {
1950 repodata_lookup_idarray($self->repo->repodata + $self->id, solvid, keyname, &r);
1953 %newobject lookup_checksum;
1954 Chksum *lookup_checksum(Id solvid, Id keyname) {
1956 const unsigned char *b = repodata_lookup_bin_checksum($self->repo->repodata + $self->id, solvid, keyname, &type);
1957 return sat_chksum_create_from_bin(type, b);
1959 void internalize() {
1960 repodata_internalize($self->repo->repodata + $self->id);
1962 void create_stubs() {
1963 repodata_create_stubs($self->repo->repodata + $self->id);
1965 void write(FILE *fp) {
1966 repodata_write($self->repo->repodata + $self->id, fp, repo_write_stdkeyfilter, 0);
1968 bool read_solv_flags(FILE *fp, int flags = 0) {
1969 Repodata *data = $self->repo->repodata + $self->id;
1970 int r, oldstate = data->state;
1971 data->state = REPODATA_LOADING;
1972 r = repo_add_solv_flags(data->repo, fp, flags | REPO_USE_LOADING);
1974 data->state = oldstate;
1977 void extend_to_repo() {
1978 Repodata *data = $self->repo->repodata + $self->id;
1979 repodata_extend_block(data, data->repo->start, data->repo->end - data->repo->start);