# on the generated c code
#
-#
-##if defined(SWIGRUBY)
-# %rename("to_s") string();
-##endif
-##if defined(SWIGPYTHON)
-# %rename("__str__") string();
-##endif
-#
-
%module solv
#ifdef SWIGRUBY
%include "typemaps.i"
+%typemap(in,numinputs=0,noblock=1) XRule **OUTPUT ($*1_ltype temp, int res = SWIG_TMPOBJ) {
+ $1 = &temp;
+}
+%typemap(argout,noblock=1) XRule **OUTPUT {
+ %append_output(SWIG_NewPointerObj((void*)(*$1), SWIGTYPE_p_XRule, SWIG_POINTER_OWN | %newpointer_flags));
+}
+
%typemaps_asval(%checkcode(POINTER), SWIG_AsValSolvFpPtr, "SWIG_AsValSolvFpPtr", FILE*);
%typemaps_asval(%checkcode(INT32), SWIG_AsValDepId, "SWIG_AsValDepId", DepId);
#ifdef ENABLE_RPMDB
#include "repo_rpmdb.h"
#endif
-#ifdef ENABLE_RPMDB_PUBKEYS
-#include "repo_rpmdb_pubkey.h"
+#ifdef ENABLE_PUBKEY
+#include "repo_pubkey.h"
#endif
#ifdef ENABLE_DEBIAN
#include "repo_deb.h"
Id type;
Id source;
Id target;
- Id dep;
+ Id dep_id;
} Ruleinfo;
typedef struct {
typedef struct {
Solver* const solv;
Id const type;
- Id const dep;
+ Id const dep_id;
} Ruleinfo;
typedef struct {
}
#if defined(SWIGRUBY)
%rename("to_s") __str__;
- %rename("inspect") __repr__;
#endif
#if defined(SWIGPERL)
%rename("str") __str__;
Id str2id(const char *str, bool create=1) {
return pool_str2id($self, str, create);
}
+ %newobject Dep;
Dep *Dep(const char *str, bool create=1) {
Id id = pool_str2id($self, str, create);
return new_Dep($self, id);
pool_createwhatprovides($self);
}
+ %newobject id2solvable;
XSolvable *id2solvable(Id id) {
return new_XSolvable($self, id);
}
}
Repo *installed;
+ const char * const errstr;
%{
SWIGINTERN void Pool_installed_set(Pool *pool, Repo *installed) {
pool_set_installed(pool, installed);
Repo *Pool_installed_get(Pool *pool) {
return pool->installed;
}
+ const char *Pool_errstr_get(Pool *pool) {
+ return pool_errstr(pool);
+ }
%}
Queue matchprovidingids(const char *match, int flags) {
return q;
}
+ %newobject Job;
Job *Job(int how, Id what) {
return new_Job($self, how, what);
}
return repo_add_solv($self, fp, flags) == 0;
}
+ %newobject add_solvable;
XSolvable *add_solvable() {
Id solvid = repo_add_solvable($self);
return new_XSolvable($self->pool, solvid);
bool add_rpmdb_reffp(FILE *reffp, int flags = 0) {
return repo_add_rpmdb_reffp($self, reffp, flags) == 0;
}
- Id add_rpm(const char *name, int flags = 0) {
- return repo_add_rpm($self, name, flags);
+ %newobject add_rpm;
+ XSolvable *add_rpm(const char *name, int flags = 0) {
+ return new_XSolvable($self->pool, repo_add_rpm($self, name, flags));
}
#endif
-#ifdef ENABLE_RPMDB_PUBKEYS
+#ifdef ENABLE_PUBKEY
+#ifdef ENABLE_RPMDB
bool add_rpmdb_pubkeys(int flags = 0) {
return repo_add_rpmdb_pubkeys($self, flags) == 0;
}
- Id add_pubkey(const char *key, int flags = 0) {
- return repo_add_pubkey($self, key, flags);
+#endif
+ %newobject add_pubkey;
+ XSolvable *add_pubkey(const char *key, int flags = 0) {
+ return new_XSolvable($self->pool, repo_add_pubkey($self, key, flags));
}
#endif
#ifdef ENABLE_RPMMD
bool add_debpackages(FILE *fp, int flags = 0) {
return repo_add_debpackages($self, fp, flags) == 0;
}
- Id add_deb(const char *name, int flags = 0) {
- return repo_add_deb($self, name, flags);
+ %newobject add_deb;
+ XSolvable *add_deb(const char *name, int flags = 0) {
+ return new_XSolvable($self->pool, repo_add_deb($self, name, flags));
}
#endif
#ifdef ENABLE_SUSEREPO
bool add_arch_local(const char *dir, int flags = 0) {
return repo_add_arch_local($self, dir, flags) == 0;
}
- Id add_arch_pkg(const char *name, int flags = 0) {
- return repo_add_arch_pkg($self, name, flags);
+ %newobject add_arch_pkg;
+ XSolvable *add_arch_pkg(const char *name, int flags = 0) {
+ return new_XSolvable($self->pool, repo_add_arch_pkg($self, name, flags));
}
#endif
void internalize() {
return new_Repo_solvable_iterator($self);
}
+ %newobject add_repodata;
XRepodata *add_repodata(int flags = 0) {
Repodata *rd = repo_add_repodata($self, flags);
return new_XRepodata($self, rd->repodataid);
return;
data = repo_id2repodata($self, $self->nrepodata - 1);
if (data->state != REPODATA_STUB)
- repodata_create_stubs(data);
+ (void)repodata_create_stubs(data);
}
#ifdef SWIGRUBY
%rename("iscontiguous?") iscontiguous;
return 0;
return 1;
}
+ %newobject first_repodata;
XRepodata *first_repodata() {
Repodata *data;
int i;
s->enhances = repo_addid_dep(s->repo, s->enhances, id, 0);
}
+ void unset(Id keyname) {
+ Solvable *s = $self->pool->solvables + $self->id;
+ repo_unset(s->repo, $self->id, keyname);
+ }
+
void add_deparray(Id keyname, DepId id, Id marker = -1) {
Solvable *s = $self->pool->solvables + $self->id;
if (marker == -1 || marker == 1) {
int solution_count() {
return solver_solution_count($self->solv, $self->id);
}
- %newobject solutions;
%typemap(out) Queue solutions Queue2Array(Solution *, 1, new_Solution(arg1, id));
+ %newobject solutions;
Queue solutions() {
Queue q;
int i, cnt;
return solver_solutionelement_count($self->solv, $self->problemid, $self->id);
}
- %newobject elements;
%typemap(out) Queue elements Queue2Array(Solutionelement *, 4, new_Solutionelement(arg1->solv, arg1->problemid, arg1->id, id, idp[1], idp[2], idp[3]));
+ %newobject elements;
Queue elements(bool expandreplaces=0) {
Queue q;
int i, cnt;
return pool_tmpjoin($self->solv->pool, "allow ", policy_illegal2str($self->solv, illegal, $self->solv->pool->solvables + $self->p, $self->solv->pool->solvables + $self->rp), 0);
return solver_solutionelement2str($self->solv, p, rp);
}
- %newobject replaceelements;
%typemap(out) Queue replaceelements Queue2Array(Solutionelement *, 1, new_Solutionelement(arg1->solv, arg1->problemid, arg1->solutionid, arg1->id, id, arg1->p, arg1->rp));
+ %newobject replaceelements;
Queue replaceelements() {
Queue q;
int illegal;
static const int SOLVER_FLAG_BEST_OBEY_POLICY = SOLVER_FLAG_BEST_OBEY_POLICY;
static const int SOLVER_FLAG_NO_AUTOTARGET = SOLVER_FLAG_NO_AUTOTARGET;
+ static const int SOLVER_REASON_UNRELATED = SOLVER_REASON_UNRELATED;
+ static const int SOLVER_REASON_UNIT_RULE = SOLVER_REASON_UNIT_RULE;
+ static const int SOLVER_REASON_KEEP_INSTALLED = SOLVER_REASON_KEEP_INSTALLED;
+ static const int SOLVER_REASON_RESOLVE_JOB = SOLVER_REASON_RESOLVE_JOB;
+ static const int SOLVER_REASON_UPDATE_INSTALLED = SOLVER_REASON_UPDATE_INSTALLED;
+ static const int SOLVER_REASON_CLEANDEPS_ERASE = SOLVER_REASON_CLEANDEPS_ERASE;
+ static const int SOLVER_REASON_RESOLVE = SOLVER_REASON_RESOLVE;
+ static const int SOLVER_REASON_WEAKDEP = SOLVER_REASON_WEAKDEP;
+ static const int SOLVER_REASON_RESOLVE_ORPHAN = SOLVER_REASON_RESOLVE_ORPHAN;
+ static const int SOLVER_REASON_RECOMMENDED = SOLVER_REASON_RECOMMENDED;
+ static const int SOLVER_REASON_SUPPLEMENTED = SOLVER_REASON_SUPPLEMENTED;
+
~Solver() {
solver_free($self);
}
Transaction *transaction() {
return solver_create_transaction($self);
}
+
+ int describe_decision(XSolvable *s, XRule **OUTPUT) {
+ int ruleid;
+ int reason = solver_describe_decision($self, s->id, &ruleid);
+ *OUTPUT = new_XRule($self, ruleid);
+ return reason;
+ }
}
%extend Transaction {
return new_XSolvable($self->pool, op);
}
- %newobject allothersolvables;
%typemap(out) Queue allothersolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
+ %newobject allothersolvables;
Queue allothersolvables(XSolvable *s) {
Queue q;
queue_init(&q);
return q;
}
+ # deprecated, use newsolvables instead
%typemap(out) Queue newpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
%newobject newpackages;
Queue newpackages() {
return q;
}
+ # deprecated, use keptsolvables instead
%typemap(out) Queue keptpackages Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
%newobject keptpackages;
Queue keptpackages() {
return q;
}
+ %typemap(out) Queue newsolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
+ %newobject newsolvables;
+ Queue newsolvables() {
+ Queue q;
+ int cut;
+ queue_init(&q);
+ cut = transaction_installedresult(self, &q);
+ queue_truncate(&q, cut);
+ return q;
+ }
+
+ %typemap(out) Queue keptsolvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
+ %newobject keptsolvables;
+ Queue keptsolvables() {
+ Queue q;
+ int cut;
+ queue_init(&q);
+ cut = transaction_installedresult(self, &q);
+ if (cut)
+ queue_deleten(&q, 0, cut);
+ return q;
+ }
+
%typemap(out) Queue steps Queue2Array(XSolvable *, 1, new_XSolvable(arg1->pool, id));
- %newobject steps ;
+ %newobject steps;
Queue steps() {
Queue q;
queue_init_clone(&q, &$self->steps);
int calc_installsizechange() {
return transaction_calc_installsizechange($self);
}
- void order(int flags) {
+ void order(int flags=0) {
transaction_order($self, flags);
}
}
cl->toid = toid;
return cl;
}
- %newobject solvables;
%typemap(out) Queue solvables Queue2Array(XSolvable *, 1, new_XSolvable(arg1->transaction->pool, id));
+ %newobject solvables;
Queue solvables() {
Queue q;
queue_init(&q);
transaction_classify_pkgs($self->transaction, $self->mode, $self->type, $self->fromid, $self->toid, &q);
return q;
}
- %newobject fromdep;
- Dep *fromdep() {
- return new_Dep($self->transaction->pool, $self->fromid);
- }
- %newobject todep;
- Dep *todep() {
- return new_Dep($self->transaction->pool, $self->toid);
- }
+ const char * const fromstr;
+ const char * const tostr;
+ %{
+ SWIGINTERN const char *TransactionClass_fromstr_get(TransactionClass *cl) {
+ return pool_id2str(cl->transaction->pool, cl->fromid);
+ }
+ SWIGINTERN const char *TransactionClass_tostr_get(TransactionClass *cl) {
+ return pool_id2str(cl->transaction->pool, cl->toid);
+ }
+ %}
}
%extend XRule {
return solver_ruleclass(xr->solv, xr->id);
}
%}
+ %newobject info;
Ruleinfo *info() {
Id type, source, target, dep;
type = solver_ruleinfo($self->solv, $self->id, &source, &target, &dep);
}
%extend Ruleinfo {
- Ruleinfo(XRule *r, Id type, Id source, Id target, Id dep) {
+ Ruleinfo(XRule *r, Id type, Id source, Id target, Id dep_id) {
Ruleinfo *ri = solv_calloc(1, sizeof(*ri));
ri->solv = r->solv;
ri->rid = r->id;
ri->type = type;
ri->source = source;
ri->target = target;
- ri->dep = dep;
+ ri->dep_id = dep_id;
return ri;
}
+ %newobject solvable;
XSolvable * const solvable;
+ %newobject othersolvable;
XSolvable * const othersolvable;
+ %newobject dep;
+ Dep * const dep;
%{
SWIGINTERN XSolvable *Ruleinfo_solvable_get(Ruleinfo *ri) {
return new_XSolvable(ri->solv->pool, ri->source);
SWIGINTERN XSolvable *Ruleinfo_othersolvable_get(Ruleinfo *ri) {
return new_XSolvable(ri->solv->pool, ri->target);
}
+ SWIGINTERN Dep *Ruleinfo_dep_get(Ruleinfo *ri) {
+ return new_Dep(ri->solv->pool, ri->dep_id);
+ }
%}
const char *problemstr() {
- return solver_problemruleinfo2str($self->solv, $self->type, $self->source, $self->target, $self->dep);
+ return solver_problemruleinfo2str($self->solv, $self->type, $self->source, $self->target, $self->dep_id);
}
}
repodata_internalize(repo_id2repodata($self->repo, $self->id));
}
void create_stubs() {
- repodata_create_stubs(repo_id2repodata($self->repo, $self->id));
+ Repodata *data = repo_id2repodata($self->repo, $self->id);
+ data = repodata_create_stubs(data);
+ $self->id = data->repodataid;
}
bool write(FILE *fp) {
return repodata_write(repo_id2repodata($self->repo, $self->id), fp) == 0;
projects / platform / upstream / libsolv.git / blobdiff