Id
repo_lookup_id(Repo *repo, Id entry, Id keyname)
{
Repodata *data;
int i;
Id id;
if (entry >= 0)
{
switch (keyname)
{
case SOLVABLE_NAME:
return repo->pool->solvables[entry].name;
case SOLVABLE_ARCH:
return repo->pool->solvables[entry].arch;
case SOLVABLE_EVR:
return repo->pool->solvables[entry].evr;
case SOLVABLE_VENDOR:
return repo->pool->solvables[entry].vendor;
}
}
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
id = repodata_lookup_id(data, entry, keyname);
if (id)
return data->localpool ? repodata_globalize_id(data, id, 1) : id;
if (repodata_lookup_type(data, entry, keyname))
return 0;
}
return 0;
}
unsigned int
repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned int notfound)
{
Repodata *data;
int i;
unsigned int value;
if (entry >= 0)
{
if (keyname == RPM_RPMDBID)
{
if (repo->rpmdbid && entry >= repo->start && entry < repo->end)
return repo->rpmdbid[entry - repo->start];
return notfound;
}
}
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
if (repodata_lookup_num(data, entry, keyname, &value))
return value;
if (repodata_lookup_type(data, entry, keyname))
return notfound;
}
return notfound;
}
int
repo_lookup_idarray(Repo *repo, Id entry, Id keyname, Queue *q)
{
Repodata *data;
int i;
if (entry >= 0)
{
switch (keyname)
{
case SOLVABLE_PROVIDES:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].provides, q);
case SOLVABLE_OBSOLETES:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].obsoletes, q);
case SOLVABLE_CONFLICTS:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].conflicts, q);
case SOLVABLE_REQUIRES:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].requires, q);
case SOLVABLE_RECOMMENDS:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].recommends, q);
case SOLVABLE_SUGGESTS:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].suggests, q);
case SOLVABLE_SUPPLEMENTS:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].supplements, q);
case SOLVABLE_ENHANCES:
return lookup_idarray_solvable(repo, repo->pool->solvables[entry].enhances, q);
}
}
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
if (repodata_lookup_idarray(data, entry, keyname, q))
{
if (data->localpool)
{
for (i = 0; i < q->count; i++)
q->elements[i] = repodata_globalize_id(data, q->elements[i], 1);
}
return 1;
}
if (repodata_lookup_type(data, entry, keyname))
break;
}
queue_empty(q);
return 0;
}
Id
repo_lookup_type(Repo *repo, Id entry, Id keyname)
{
Repodata *data;
int i;
Id type;
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
type = repodata_lookup_type(data, entry, keyname);
if (type)
return type == REPOKEY_TYPE_DELETED ? 0 : type;
}
return 0;
}
const unsigned char *
repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep)
{
Repodata *data;
int i;
const unsigned char *chk;
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
chk = repodata_lookup_bin_checksum(data, entry, keyname, typep);
if (chk)
return chk;
if (repodata_lookup_type(data, entry, keyname))
return 0;
}
*typep = 0;
return 0;
}
const char *
repo_lookup_str(Repo *repo, Id entry, Id keyname)
{
Pool *pool = repo->pool;
Repodata *data;
int i;
const char *str;
if (entry >= 0)
{
switch (keyname)
{
case SOLVABLE_NAME:
return pool_id2str(pool, pool->solvables[entry].name);
case SOLVABLE_ARCH:
return pool_id2str(pool, pool->solvables[entry].arch);
case SOLVABLE_EVR:
return pool_id2str(pool, pool->solvables[entry].evr);
case SOLVABLE_VENDOR:
return pool_id2str(pool, pool->solvables[entry].vendor);
}
}
FOR_REPODATAS(repo, i, data)
{
if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
continue;
if (!repodata_precheck_keyname(data, keyname))
continue;
str = repodata_lookup_str(data, entry, keyname);
if (str)
return str;
if (repodata_lookup_type(data, entry, keyname))
return 0;
}
return 0;
}
static void
repo_addfileprovides_search_filtered(Repo *repo, struct addfileprovides_cbdata *cbd, int filteredid, Map *postpone)
{
Repodata *data = repo->repodata + filteredid;
Map *providedids = cbd->providedids;
int rdid;
int start, end, p, i;
Map old_todo;
int old_todo_start, old_todo_end;
start = cbd->todo_start > data->start ? cbd->todo_start : data->start;
end = cbd->todo_end > data->end ? data->end : cbd->todo_end;
if (providedids)
{
/* check if all solvables are in the provide range */
if (start < cbd->provstart || end > cbd->provend)
{
/* unclear, check each solvable */
for (p = start; p < end; p++)
{
if (p >= cbd->provstart && p < cbd->provend)
continue;
if (data->incoreoffset[p - data->start] && MAPTST(cbd->todo, p - repo->start))
{
providedids = 0; /* nope, cannot prune with providedids */
break;
}
}
}
}
/* check if the filtered files are enough */
for (i = 0; i < cbd->nfiles; i++)
{
if (providedids && MAPTST(providedids, cbd->ids[i])) /* this one is already provided */
continue;
if (!repodata_filelistfilter_matches(data, pool_id2str(repo->pool, cbd->ids[i])))
break;
}
if (i < cbd->nfiles)
{
/* nope, need to search the extensions as well. postpone. */
for (p = start; p < end; p++)
{
if (data->incoreoffset[p - data->start] && MAPTST(cbd->todo, p - repo->start))
{
if (!postpone->size)
map_grow(postpone, repo->nsolvables);
MAPSET(postpone, p - repo->start);
MAPCLR(cbd->todo, p - repo->start);
}
}
prune_todo_range(repo, cbd);
return;
}
/* now check if there is no data marked withour EXTENSION */
/* limit todo to the solvables in this repodata */
old_todo_start = cbd->todo_start;
old_todo_end = cbd->todo_end;
old_todo = *cbd->todo;
map_init(cbd->todo, repo->nsolvables);
for (p = start; p < end; p++)
if (data->incoreoffset[p - data->start] && MAPTST(&old_todo, p - repo->start))
{
MAPCLR(&old_todo, p - repo->start);
MAPSET(cbd->todo, p - repo->start);
}
prune_todo_range(repo, cbd);
/* do the check */
for (rdid = repo->nrepodata - 1, data = repo->repodata + rdid; rdid > filteredid ; rdid--, data--)
{
if (data->filelisttype == REPODATA_FILELIST_EXTENSION)
continue;
if (data->start >= cbd->todo_end || data->end <= cbd->todo_start)
continue;
if (!repodata_has_keyname(data, SOLVABLE_FILELIST))
continue;
if (!repodata_intersects_todo(data, cbd))
continue;
/* oh no, this filelist data is not tagged with REPODATA_FILELIST_EXTENSION! */
/* postpone entries that have filelist data */
start = cbd->todo_start > data->start ? cbd->todo_start : data->start;
end = cbd->todo_end > data->end ? data->end : cbd->todo_end;
for (p = start; p < end; p++)
if (MAPTST(cbd->todo, p - repo->start))
if (repodata_lookup_type(data, p, SOLVABLE_FILELIST))
{
if (!postpone->size)
map_grow(postpone, repo->nsolvables);
MAPSET(postpone, p - repo->start);
MAPCLR(cbd->todo, p - repo->start);
}
prune_todo_range(repo, cbd);
if (cbd->todo_start >= cbd->todo_end)
break;
}
/* do the search over the filtered file list with the remaining entries*/
if (cbd->todo_start < cbd->todo_end)
repodata_addfileprovides_search(repo->repodata + filteredid, cbd);
/* restore todo map */
map_free(cbd->todo);
*cbd->todo = old_todo;
cbd->todo_start = old_todo_start;
cbd->todo_end = old_todo_end;
prune_todo_range(repo, cbd);
}
