static const Id SOLVER_ERASE = SOLVER_ERASE;
static const Id SOLVER_UPDATE = SOLVER_UPDATE;
static const Id SOLVER_WEAKENDEPS = SOLVER_WEAKENDEPS;
- static const Id SOLVER_NOOBSOLETES = SOLVER_NOOBSOLETES;
+ static const Id SOLVER_MULTIVERSION = SOLVER_MULTIVERSION;
static const Id SOLVER_LOCK = SOLVER_LOCK;
static const Id SOLVER_DISTUPGRADE = SOLVER_DISTUPGRADE;
static const Id SOLVER_VERIFY = SOLVER_VERIFY;
{
Id p, pp;
int pruneyou = 0;
- Map installedmap, noobsmap;
+ Map installedmap, multiversionmap;
Solvable *s;
- map_init(&noobsmap, 0);
+ map_init(&multiversionmap, 0);
map_init(&installedmap, pool->nsolvables);
- solver_calculate_noobsmap(pool, job, &noobsmap);
+ solver_calculate_multiversionmap(pool, job, &multiversionmap);
if (pool->installed)
FOR_REPO_SOLVABLES(pool->installed, p, s)
MAPSET(&installedmap, p);
type = solvable_lookup_str(s, SOLVABLE_PATCHCATEGORY);
if (type && !strcmp(type, "optional"))
continue;
- r = solvable_trivial_installable_map(s, &installedmap, 0, &noobsmap);
+ r = solvable_trivial_installable_map(s, &installedmap, 0, &multiversionmap);
if (r == -1)
continue;
if (solvable_lookup_bool(s, UPDATE_RESTART) && r == 0)
queue_push2(job, SOLVER_SOLVABLE, p);
}
map_free(&installedmap);
- map_free(&noobsmap);
+ map_free(&multiversionmap);
}
#define MODE_LIST 0
}
// multiversion test
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae", 1));
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-base", 1));
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-extra", 1));
+ // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae", 1));
+ // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-base", 1));
+ // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-extra", 1));
#if 0
queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
#endif
solv = solver_create(pool);
solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1);
+#ifdef FEDORA
+ solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1);
+#endif
if (mainmode == MODE_ERASE)
solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1); /* don't nag */
solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1);
{ SOLVER_ERASE, "erase" },
{ SOLVER_UPDATE, "update" },
{ SOLVER_WEAKENDEPS, "weakendeps" },
- { SOLVER_NOOBSOLETES, "noobsoletes" },
+ { SOLVER_MULTIVERSION, "multiversion" },
+ { SOLVER_MULTIVERSION, "noobsoletes" }, /* old name */
{ SOLVER_LOCK, "lock" },
{ SOLVER_DISTUPGRADE, "distupgrade" },
{ SOLVER_VERIFY, "verify" },
pool_tmpappend;
pool_tmpjoin;
pool_trivial_installable;
- pool_trivial_installable_noobsoletesmap;
+ pool_trivial_installable_multiversionmap;
pool_vendor2mask;
queue_alloc_one;
queue_alloc_one_head;
solver_allruleinfos;
solver_calc_duchanges;
solver_calc_installsizechange;
+ solver_calculate_multiversionmap;
solver_calculate_noobsmap;
solver_create;
solver_create_decisions_obsoletesmap;
return 0;
}
-static inline int providedbyinstalled(Pool *pool, unsigned char *map, Id dep, int ispatch, Map *noobsoletesmap)
+static inline int providedbyinstalled(Pool *pool, unsigned char *map, Id dep, int ispatch, Map *multiversionmap)
{
Id p, pp;
int r = 0;
return 1; /* always boring, as never constraining */
if (ispatch && !pool_match_nevr(pool, pool->solvables + p, dep))
continue;
- if (ispatch && noobsoletesmap && noobsoletesmap->size && MAPTST(noobsoletesmap, p) && ISRELDEP(dep))
+ if (ispatch && multiversionmap && multiversionmap->size && MAPTST(multiversionmap, p) && ISRELDEP(dep))
if (providedbyinstalled_multiversion(pool, map, p, dep))
continue;
if ((map[p] & 9) == 9)
*/
void
-pool_trivial_installable_noobsoletesmap(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res, Map *noobsoletesmap)
+pool_trivial_installable_multiversionmap(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res, Map *multiversionmap)
{
int i, r, m, did;
Id p, *dp, con, *conp, req, *reqp;
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
- if ((providedbyinstalled(pool, map, con, ispatch, noobsoletesmap) & 1) != 0)
+ if ((providedbyinstalled(pool, map, con, ispatch, multiversionmap) & 1) != 0)
{
map[p] = 2;
did = 0;
if ((m == 1 || m == 17) && ISRELDEP(con))
{
con = dep2name(pool, con);
- if ((providedbyinstalled(pool, map, con, ispatch, noobsoletesmap) & 1) != 0)
+ if ((providedbyinstalled(pool, map, con, ispatch, multiversionmap) & 1) != 0)
m = 9;
}
}
void
pool_trivial_installable(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res)
{
- pool_trivial_installable_noobsoletesmap(pool, installedmap, pkgs, res, 0);
+ pool_trivial_installable_multiversionmap(pool, installedmap, pkgs, res, 0);
}
const char *
/* search position */
Datapos pos;
- Queue pooljobs; /* fixed jobs, like USERINSTALLED/NOOBSOLETES */
+ Queue pooljobs; /* fixed jobs, like USERINSTALLED/MULTIVERSION */
#ifdef LIBSOLV_INTERNAL
/* flags to tell the library how the installed package manager works */
void pool_set_languages(Pool *pool, const char **languages, int nlanguages);
Id pool_id2langid(Pool *pool, Id id, const char *lang, int create);
-int solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *noobsoletesmap);
-int solvable_trivial_installable_repo(Solvable *s, struct _Repo *installed, Map *noobsoletesmap);
-int solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *noobsoletesmap);
+int solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *multiversionmap);
+int solvable_trivial_installable_repo(Solvable *s, struct _Repo *installed, Map *multiversionmap);
+int solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *multiversionmap);
int solvable_is_irrelevant_patch(Solvable *s, Map *installedmap);
void pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap);
void pool_calc_duchanges(Pool *pool, Map *installedmap, DUChanges *mps, int nmps);
int pool_calc_installsizechange(Pool *pool, Map *installedmap);
void pool_trivial_installable(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res);
-void pool_trivial_installable_noobsoletesmap(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res, Map *noobsoletesmap);
+void pool_trivial_installable_multiversionmap(Pool *pool, Map *installedmap, Queue *pkgs, Queue *res, Map *multiversionmap);
const char *pool_lookup_str(Pool *pool, Id entry, Id keyname);
Id pool_lookup_id(Pool *pool, Id entry, Id keyname);
if (rp > 0 && solv->decisionmap[rp] > 0 && pool->solvables[rp].repo != solv->installed)
{
mvrp = rp;
- if (!(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, rp)))
+ if (!(solv->multiversion.size && MAPTST(&solv->multiversion, rp)))
break;
}
}
if (rp > 0 && solv->decisionmap[rp] > 0 && pool->solvables[rp].repo != solv->installed)
{
mvrp = rp;
- if (!(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, rp)))
+ if (!(solv->multiversion.size && MAPTST(&solv->multiversion, rp)))
break;
}
if (!rp && mvrp)
s = pool->solvables + p;
if (s->name != sn->name || s->arch != sn->arch)
continue;
- if (!MAPTST(&solv->noobsoletes, p))
+ if (!MAPTST(&solv->multiversion, p))
continue;
if (pool_match_nevr(pool, pool->solvables + p, con))
continue;
}
p = 0; /* make it a negative assertion, aka 'uninstallable' */
}
- if (p && ispatch && solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && ISRELDEP(con))
+ if (p && ispatch && solv->multiversion.size && MAPTST(&solv->multiversion, p) && ISRELDEP(con))
{
- /* our patch conflicts with a noobsoletes (aka multiversion) package */
+ /* our patch conflicts with a multiversion package */
p = -makemultiversionconflict(solv, p, con);
}
/* rule: -n|-p: either solvable _or_ provider of conflict */
*/
if ((!installed || s->repo != installed) || !pool->noinstalledobsoletes)
{
- int noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
+ int multi = solv->multiversion.size && MAPTST(&solv->multiversion, n);
int isinstalled = (installed && s->repo == installed);
- if (s->obsoletes && (!noobs || solv->keepexplicitobsoletes))
+ if (s->obsoletes && (!multi || solv->keepexplicitobsoletes))
{
obsp = s->repo->idarraydata + s->obsoletes;
/* foreach obsoletes */
continue;
/* we still obsolete packages with same nevra, like rpm does */
/* (actually, rpm mixes those packages. yuck...) */
- if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
+ if (multi && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
continue;
if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
continue;
if (!allow_all && !solv->dupmap_all && solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
addduppackages(solv, s, &qs);
- if (!allow_all && qs.count && solv->noobsoletes.size)
+ if (!allow_all && qs.count && solv->multiversion.size)
{
int i, j;
d = pool_queuetowhatprovides(pool, &qs);
- /* filter out all noobsoletes packages as they don't update */
+ /* filter out all multiversion packages as they don't update */
for (i = j = 0; i < qs.count; i++)
{
- if (MAPTST(&solv->noobsoletes, qs.elements[i]))
+ if (MAPTST(&solv->multiversion, qs.elements[i]))
{
/* it's ok if they have same nevra */
Solvable *ps = pool->solvables + qs.elements[i];
/*
* add all installed packages that package p obsoletes to Queue q.
* Package p is not installed. Also, we know that if
- * solv->keepexplicitobsoletes is not set, p is not in the noobs map.
+ * solv->keepexplicitobsoletes is not set, p is not in the multiversion map.
* Entries may get added multiple times.
*/
static void
Id obs, *obsp;
Id lastp2 = 0;
- if (!solv->keepexplicitobsoletes || !(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p)))
+ if (!solv->keepexplicitobsoletes || !(solv->multiversion.size && MAPTST(&solv->multiversion, p)))
{
FOR_PROVIDES(p2, pp2, s->name)
{
return;
/* now the hard part: disable some update rules */
- /* first check if we have noobs or installed packages in the job */
+ /* first check if we have multiversion or installed packages in the job */
i = j = 0;
FOR_JOB_SELECT(p, pp, select, what)
{
if (pool->solvables[p].repo == installed)
j = p;
- else if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && !solv->keepexplicitobsoletes)
+ else if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
return;
i++;
}
/* just one installed literal */
if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
continue;
- /* noobs is bad */
- if (solv->noobsoletes.size && !solv->keepexplicitobsoletes)
+ /* multiversion is bad */
+ if (solv->multiversion.size && !solv->keepexplicitobsoletes)
{
FOR_RULELITERALS(p, jp, r)
- if (MAPTST(&solv->noobsoletes, p))
+ if (MAPTST(&solv->multiversion, p))
break;
if (p)
continue;
return 0;
}
-static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep, int ispatch, Map *noobsoletesmap)
+static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep, int ispatch, Map *multiversionmap)
{
Id p, pp;
FOR_PROVIDES(p, pp, dep)
return -1;
if (ispatch && !pool_match_nevr(pool, pool->solvables + p, dep))
continue;
- if (ispatch && noobsoletesmap && noobsoletesmap->size && MAPTST(noobsoletesmap, p) && ISRELDEP(dep))
+ if (ispatch && multiversionmap && multiversionmap->size && MAPTST(multiversionmap, p) && ISRELDEP(dep))
if (providedbyinstalled_multiversion(pool, installed, p, dep))
continue;
if (MAPTST(installed, p))
* -1: solvable is installable, but doesn't constrain any installed packages
*/
int
-solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *noobsoletesmap)
+solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
Solvable *s2;
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
- if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
+ if (providedbyinstalled(pool, installedmap, con, ispatch, multiversionmap))
{
if (ispatch && solvable_is_irrelevant_patch(s, installedmap))
return -1;
if (!interesting && ISRELDEP(con))
{
con = dep2name(pool, con);
- if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
+ if (providedbyinstalled(pool, installedmap, con, ispatch, multiversionmap))
interesting = 1;
}
}
* by a queue.
*/
int
-solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *noobsoletesmap)
+solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
int i;
if (p > 0) /* makes it work with decisionq */
MAPSET(&installedmap, p);
}
- r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
+ r = solvable_trivial_installable_map(s, &installedmap, 0, multiversionmap);
map_free(&installedmap);
return r;
}
* by a repo containing the installed solvables.
*/
int
-solvable_trivial_installable_repo(Solvable *s, Repo *installed, Map *noobsoletesmap)
+solvable_trivial_installable_repo(Solvable *s, Repo *installed, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
Id p;
map_init(&installedmap, pool->nsolvables);
FOR_REPO_SOLVABLES(installed, p, s2)
MAPSET(&installedmap, p);
- r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
+ r = solvable_trivial_installable_map(s, &installedmap, 0, multiversionmap);
map_free(&installedmap);
return r;
}
map_free(&solv->suggestsmap);
map_free(&solv->noupdate);
map_free(&solv->weakrulemap);
- map_free(&solv->noobsoletes);
+ map_free(&solv->multiversion);
map_free(&solv->updatemap);
map_free(&solv->bestupdatemap);
queue_empty(&dq);
if (!MAPTST(&solv->noupdate, i - installed->start) && (solv->decisionmap[i] < 0 || solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, i - installed->start)) || rr->p != i))
{
- if (solv->noobsoletes.size && solv->multiversionupdaters
+ if (solv->multiversion.size && solv->multiversionupdaters
&& (d = solv->multiversionupdaters[i - installed->start]) != 0)
{
/* special multiversion handling, make sure best version is chosen */
continue;
if (solv->decisionmap[p] <= 0)
continue;
- if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p))
+ if (solv->multiversion.size && MAPTST(&solv->multiversion, p))
continue;
obsp = s->repo->idarraydata + s->obsoletes;
/* foreach obsoletes */
/* multiversion doesn't mix well with supplements.
* filter supplemented packages where we already decided
* to install a different version (see bnc#501088) */
- if (dqs.count && solv->noobsoletes.size)
+ if (dqs.count && solv->multiversion.size)
{
for (i = j = 0; i < dqs.count; i++)
{
p = dqs.elements[i];
- if (MAPTST(&solv->noobsoletes, p))
+ if (MAPTST(&solv->multiversion, p))
{
Id p2, pp2;
s = pool->solvables + p;
void
-solver_calculate_noobsmap(Pool *pool, Queue *job, Map *noobsmap)
+solver_calculate_multiversionmap(Pool *pool, Queue *job, Map *multiversionmap)
{
int i;
Id how, what, select;
for (i = 0; i < job->count; i += 2)
{
how = job->elements[i];
- if ((how & SOLVER_JOBMASK) != SOLVER_NOOBSOLETES)
+ if ((how & SOLVER_JOBMASK) != SOLVER_MULTIVERSION)
continue;
what = job->elements[i + 1];
select = how & SOLVER_SELECTMASK;
- if (!noobsmap->size)
- map_grow(noobsmap, pool->nsolvables);
+ if (!multiversionmap->size)
+ map_grow(multiversionmap, pool->nsolvables);
if (select == SOLVER_SOLVABLE_ALL)
{
FOR_POOL_SOLVABLES(p)
- MAPSET(noobsmap, p);
+ MAPSET(multiversionmap, p);
}
else if (select == SOLVER_SOLVABLE_REPO)
{
Repo *repo = pool_id2repo(pool, what);
if (repo)
FOR_REPO_SOLVABLES(repo, p, s)
- MAPSET(noobsmap, p);
+ MAPSET(multiversionmap, p);
}
FOR_JOB_SELECT(p, pp, select, what)
- MAPSET(noobsmap, p);
+ MAPSET(multiversionmap, p);
}
}
+void
+solver_calculate_noobsmap(Pool *pool, Queue *job, Map *multiversionmap)
+{
+ solver_calculate_multiversionmap(pool, job, multiversionmap);
+}
+
/*
* add a rule created by a job, record job number and weak flag
*/
solv->choicerules_ref = solv_free(solv->choicerules_ref);
if (solv->noupdate.size)
map_empty(&solv->noupdate);
- if (solv->noobsoletes.size)
+ if (solv->multiversion.size)
{
- map_free(&solv->noobsoletes);
- map_init(&solv->noobsoletes, 0);
+ map_free(&solv->multiversion);
+ map_init(&solv->multiversion, 0);
}
solv->updatemap_all = 0;
if (solv->updatemap.size)
* use addedmap bitmap to make sure we don't create rules twice
*/
- /* create noobsolete map if needed */
- solver_calculate_noobsmap(pool, job, &solv->noobsoletes);
+ /* create multiversion map if needed */
+ solver_calculate_multiversionmap(pool, job, &solv->multiversion);
map_init(&addedmap, pool->nsolvables);
MAPSET(&addedmap, SYSTEMSOLVABLE);
s = pool->solvables + what;
weaken_solvable_deps(solv, what);
break;
- case SOLVER_NOOBSOLETES:
- POOL_DEBUG(SOLV_DEBUG_JOB, "job: %sno obsolete %s\n", weak ? "weak " : "", solver_select2str(pool, select, what));
+ case SOLVER_MULTIVERSION:
+ POOL_DEBUG(SOLV_DEBUG_JOB, "job: %smultiversion %s\n", weak ? "weak " : "", solver_select2str(pool, select, what));
break;
case SOLVER_LOCK:
POOL_DEBUG(SOLV_DEBUG_JOB, "job: %slock %s\n", weak ? "weak " : "", solver_select2str(pool, select, what));
Transaction *
solver_create_transaction(Solver *solv)
{
- return transaction_create_decisionq(solv->pool, &solv->decisionq, &solv->noobsoletes);
+ return transaction_create_decisionq(solv->pool, &solv->decisionq, &solv->multiversion);
}
void solver_get_orphaned(Solver *solv, Queue *orphanedq)
continue;
if (solv->decisionmap[p] <= 0)
continue;
- if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p))
+ if (solv->multiversion.size && MAPTST(&solv->multiversion, p))
continue;
obsp = s->repo->idarraydata + s->obsoletes;
/* foreach obsoletes */
Map installedmap;
int i;
pool_create_state_maps(pool, &solv->decisionq, &installedmap, 0);
- pool_trivial_installable_noobsoletesmap(pool, &installedmap, pkgs, res, solv->noobsoletes.size ? &solv->noobsoletes : 0);
+ pool_trivial_installable_multiversionmap(pool, &installedmap, pkgs, res, solv->multiversion.size ? &solv->multiversion : 0);
for (i = 0; i < res->count; i++)
if (res->elements[i] != -1)
{
Map noupdate; /* don't try to update these
installed solvables */
- Map noobsoletes; /* ignore obsoletes for these (multiinstall) */
+ Map multiversion; /* ignore obsoletes for these (multiinstall) */
Map updatemap; /* bring these installed packages to the newest version */
int updatemap_all; /* bring all packages to the newest version */
#define SOLVER_ERASE 0x0200
#define SOLVER_UPDATE 0x0300
#define SOLVER_WEAKENDEPS 0x0400
-#define SOLVER_NOOBSOLETES 0x0500
+#define SOLVER_MULTIVERSION 0x0500
#define SOLVER_LOCK 0x0600
#define SOLVER_DISTUPGRADE 0x0700
#define SOLVER_VERIFY 0x0800
#define SOLVER_SETMASK 0x7f000000
+/* legacy */
+#define SOLVER_NOOBSOLETES SOLVER_MULTIVERSION
+
#define SOLVER_REASON_UNRELATED 0
#define SOLVER_REASON_UNIT_RULE 1
#define SOLVER_REASON_KEEP_INSTALLED 2
extern void solver_describe_weakdep_decision(Solver *solv, Id p, Queue *whyq);
-extern void solver_calculate_noobsmap(Pool *pool, Queue *job, Map *noobsmap);
+extern void solver_calculate_multiversionmap(Pool *pool, Queue *job, Map *multiversionmap);
+extern void solver_calculate_noobsmap(Pool *pool, Queue *job, Map *multiversionmap); /* obsolete */
extern void solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap);
/* XXX: why is this not static? */
for (i = 0; i < solv->decisionq.count; i++)
{
Id pp, n;
- int noobs;
+ int multi;
n = solv->decisionq.elements[i];
if (n < 0)
s = pool->solvables + n;
if (s->repo == installed) /* obsoletes don't count for already installed packages */
continue;
- noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
+ multi = solv->multiversion.size && MAPTST(&solv->multiversion, n);
FOR_PROVIDES(p, pp, s->name)
{
Solvable *ps = pool->solvables + p;
- if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
+ if (multi && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
continue;
if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
continue;
continue;
if (!s->obsoletes)
continue;
- if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n))
+ if (solv->multiversion.size && MAPTST(&solv->multiversion, n))
continue;
obsp = s->repo->idarraydata + s->obsoletes;
while ((obs = *obsp++) != 0)
case SOLVER_WEAKENDEPS:
strstart = "weaken deps of ";
break;
- case SOLVER_NOOBSOLETES:
+ case SOLVER_MULTIVERSION:
strstart = "multi version ";
break;
case SOLVER_LOCK:
}
else
{
- int noobs = trans->noobsmap.size && MAPTST(&trans->noobsmap, p);
- if (noobs)
+ int multi = trans->multiversionmap.size && MAPTST(&trans->multiversionmap, p);
+ if (multi)
return p2 ? SOLVER_TRANSACTION_MULTIREINSTALL : SOLVER_TRANSACTION_MULTIINSTALL;
if (!p2)
return SOLVER_TRANSACTION_INSTALL;
Pool *pool = trans->pool;
Queue *ti = &trans->transaction_info;
Repo *installed = pool->installed;
- int i, j, noobs;
+ int i, j, multi;
Id p, p2, pp2;
Solvable *s, *s2;
s = pool->solvables + p;
if (!s->repo || s->repo == installed)
continue;
- noobs = trans->noobsmap.size && MAPTST(&trans->noobsmap, p);
+ multi = trans->multiversionmap.size && MAPTST(&trans->multiversionmap, p);
FOR_PROVIDES(p2, pp2, s->name)
{
if (!MAPTST(&trans->transactsmap, p2))
s2 = pool->solvables + p2;
if (s2->repo != installed)
continue;
- if (noobs && (s->name != s2->name || s->evr != s2->evr || s->arch != s2->arch))
+ if (multi && (s->name != s2->name || s->evr != s2->evr || s->arch != s2->arch))
continue;
if (!pool->implicitobsoleteusesprovides && s->name != s2->name)
continue;
continue;
queue_push2(ti, p, p2);
}
- if (s->obsoletes && !noobs)
+ if (s->obsoletes && !multi)
{
Id obs, *obsp = s->repo->idarraydata + s->obsoletes;
while ((obs = *obsp++) != 0)
Transaction *
-transaction_create_decisionq(Pool *pool, Queue *decisionq, Map *noobsmap)
+transaction_create_decisionq(Pool *pool, Queue *decisionq, Map *multiversionmap)
{
Repo *installed = pool->installed;
- int i, neednoobs;
+ int i, needmulti;
Id p;
Solvable *s;
Transaction *trans;
trans = transaction_create(pool);
- if (noobsmap && !noobsmap->size)
- noobsmap = 0; /* ignore empty map */
+ if (multiversionmap && !multiversionmap->size)
+ multiversionmap = 0; /* ignore empty map */
queue_empty(&trans->steps);
map_init(&trans->transactsmap, pool->nsolvables);
- neednoobs = 0;
+ needmulti = 0;
for (i = 0; i < decisionq->count; i++)
{
p = decisionq->elements[i];
continue;
#endif
MAPSET(&trans->transactsmap, p);
- if (noobsmap && MAPTST(noobsmap, p))
- neednoobs = 1;
+ if (multiversionmap && MAPTST(multiversionmap, p))
+ needmulti = 1;
}
}
MAPCLR(&trans->transactsmap, SYSTEMSOLVABLE);
- if (neednoobs)
- map_init_clone(&trans->noobsmap, noobsmap);
+ if (needmulti)
+ map_init_clone(&trans->multiversionmap, multiversionmap);
create_transaction_info(trans, decisionq);
memcpy(trans->transaction_installed, srctrans->transaction_installed, (installed->end - installed->start) * sizeof(Id));
}
map_init_clone(&trans->transactsmap, &srctrans->transactsmap);
- map_init_clone(&trans->noobsmap, &srctrans->noobsmap);
+ map_init_clone(&trans->multiversionmap, &srctrans->multiversionmap);
if (srctrans->orderdata)
{
struct _TransactionOrderdata *od = srctrans->orderdata;
queue_free(&trans->transaction_info);
trans->transaction_installed = solv_free(trans->transaction_installed);
map_free(&trans->transactsmap);
- map_free(&trans->noobsmap);
+ map_free(&trans->multiversionmap);
transaction_free_orderdata(trans);
free(trans);
}
Queue transaction_info;
Id *transaction_installed;
Map transactsmap;
- Map noobsmap;
+ Map multiversionmap;
struct _TransactionOrderdata *orderdata;
#endif
#define SOLVER_TRANSACTION_KEEP_ORDERDATA (1 << 0)
extern Transaction *transaction_create(struct _Pool *pool);
-extern Transaction *transaction_create_decisionq(struct _Pool *pool, Queue *decisionq, Map *noobsmap);
+extern Transaction *transaction_create_decisionq(struct _Pool *pool, Queue *decisionq, Map *multiversionmap);
extern Transaction *transaction_create_clone(Transaction *srctrans);
extern void transaction_free(Transaction *trans);
extern void transaction_free_orderdata(Transaction *trans);