static void rpmalMakeIndex(rpmal al)
{
availablePackage alp;
int i;
int providesCnt = 0;
int fileCnt = 0;
if (al == NULL || al->list == NULL) return;
if (al->providesHash != NULL || al->fileHash != NULL)
return;
for (i = 0; i < al->size; i++) {
alp = al->list + i;
if (alp->provides != NULL)
providesCnt += rpmdsCount(alp->provides);
if (alp->fi != NULL)
fileCnt += rpmfiFC(alp->fi);
}
al->providesHash = rpmalProvidesHashCreate(providesCnt/4+128, rstrhash,
strcmp, NULL, NULL);
al->fileHash = rpmalFileHashCreate(fileCnt/4+128, fileHash, fileCompare,
NULL, NULL);
for (i = 0; i < al->size; i++) {
alp = al->list + i;
rpmalAddProvides(al, i, alp->provides);
rpmalAddFiles(al, i, alp->fi);
}
}
static int depnevrsTagFiltered(Header h, rpmtd td, headerGetFlags hgflags,
rpmTagVal tag, int strong)
{
rpmds ds = rpmdsNew(h, tag, 0);
int ndeps = rpmdsCount(ds);
if (ndeps > 0) {
char **deps = xmalloc(sizeof(*deps) * ndeps);
ndeps = 0;
while (rpmdsNext(ds) >= 0) {
if ((rpmdsFlags(ds) & RPMSENSE_STRONG) == (strong ? RPMSENSE_STRONG : 0))
deps[ndeps++] = rpmdsNewDNEVR(NULL, ds);
}
if (ndeps) {
td->data = deps;
td->type = RPM_STRING_ARRAY_TYPE;
td->count = ndeps;
td->flags |= (RPMTD_ALLOCED | RPMTD_PTR_ALLOCED);
} else {
_free(deps);
}
}
rpmdsFree(ds);
return (ndeps > 0);
}
static VALUE
rpmds_Count_get(VALUE s)
{
rpmds ds = rpmds_ptr(s);
if (_debug)
fprintf(stderr, "==> %s(0x%lx) ptr %p\n", __FUNCTION__, s, ds);
return INT2FIX(rpmdsCount(ds));
}
static void rpmalMakeObsoletesIndex(rpmal al)
{
availablePackage alp;
int i, obsoletesCnt = 0;
for (i = 0; i < al->size; i++) {
alp = al->list + i;
obsoletesCnt += rpmdsCount(alp->obsoletes);
}
al->obsoletesHash = rpmalDepHashCreate(obsoletesCnt/4+128,
sidHash, sidCmp, NULL, NULL);
for (i = 0; i < al->size; i++) {
alp = al->list + i;
rpmalAddObsoletes(al, i, alp->obsoletes);
}
}
static void rpmalAddObsoletes(rpmal al, rpmalNum pkgNum, rpmds obsoletes)
{
struct availableIndexEntry_s indexEntry;
rpm_color_t dscolor;
int dc = rpmdsCount(obsoletes);
indexEntry.pkgNum = pkgNum;
for (int i = 0; i < dc; i++) {
/* Obsoletes shouldn't be colored but just in case... */
dscolor = rpmdsColorIndex(obsoletes, i);
if (al->tscolor && dscolor && !(al->tscolor & dscolor))
continue;
indexEntry.entryIx = i;;
rpmalDepHashAddEntry(al->obsoletesHash,
rpmdsNIdIndex(obsoletes, i), indexEntry);
}
}
static int depnevrsTag(Header h, rpmtd td, headerGetFlags hgflags,
rpmTagVal tag)
{
rpmds ds = rpmdsNew(h, tag, 0);
int ndeps = rpmdsCount(ds);
if (ndeps > 0) {
char **deps = xmalloc(sizeof(*deps) * ndeps);
int i;
while ((i = rpmdsNext(ds)) >= 0) {
deps[i] = rpmdsNewDNEVR(NULL, ds);
}
td->data = deps;
td->type = RPM_STRING_ARRAY_TYPE;
td->count = ndeps;
td->flags |= (RPMTD_ALLOCED | RPMTD_PTR_ALLOCED);
}
rpmdsFree(ds);
return (ndeps > 0);
}
static PyObject *
rpmds_subscript(rpmdsObject * s, PyObject * key)
{
int ix;
rpmdsDepObject *dso = NULL;
if (!PyInt_Check(key)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return NULL;
}
ix = (int) PyInt_AsLong(key);
if (ix >= 0 && ix < rpmdsCount(s->ds)) {
/* XXX work around rpmds brokenness, fix this junk in rpm... */
rpmdsSetIx(s->ds, ix-1);
if (rpmdsNext(s->ds) >= 0) {
dso = rpmdsDep_Wrap(s->ds);
}
}
if (dso == NULL) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
}
return (PyObject*) dso;
}
static void rpmalAddProvides(rpmal al, rpmalNum pkgNum, rpmds provides)
{
struct availableIndexEntry_s indexEntry;
rpm_color_t dscolor;
int skipconf = (al->tsflags & RPMTRANS_FLAG_NOCONFIGS);
int dc = rpmdsCount(provides);
indexEntry.pkgNum = pkgNum;
for (int i = 0; i < dc; i++) {
/* Ignore colored provides not in our rainbow. */
dscolor = rpmdsColorIndex(provides, i);
if (al->tscolor && dscolor && !(al->tscolor & dscolor))
continue;
/* Ignore config() provides if the files wont be installed */
if (skipconf & (rpmdsFlagsIndex(provides, i) & RPMSENSE_CONFIG))
continue;
indexEntry.entryIx = i;;
rpmalDepHashAddEntry(al->providesHash,
rpmdsNIdIndex(provides, i), indexEntry);
}
}
int rpmdsMerge(rpmds * dsp, rpmds ods)
{
rpmds ds;
int save;
int ocount;
if (dsp == NULL || ods == NULL)
return -1;
ocount = rpmdsCount(*dsp);
/* If not initialized yet, dup the 1st entry. */
if (*dsp == NULL) {
save = ods->Count;
ods->Count = 1;
*dsp = rpmdsDup(ods);
ods->Count = save;
}
ds = *dsp;
if (ds == NULL)
return -1;
/* Ensure EVR and Flags exist */
if (ds->EVR == NULL)
ds->EVR = xcalloc(ds->Count, sizeof(*ds->EVR));
if (ds->Flags == NULL)
ds->Flags = xcalloc(ds->Count, sizeof(*ds->Flags));
if (ds->ti == NULL && ods->ti) {
int i;
ds->ti = xcalloc(ds->Count, sizeof(*ds->ti));
for (i = 0; i < ds->Count; i++)
ds->ti[i] = -1;
}
/*
* Add new entries.
*/
save = ods->i;
ods = rpmdsInit(ods);
while (rpmdsNext(ods) >= 0) {
const char *OEVR;
unsigned int u;
/*
* If this entry is already present, don't bother.
*/
if (doFind(ds, ods, &u) >= 0)
continue;
/*
* Insert new entry. Ensure pool is unfrozen to allow additions.
*/
rpmstrPoolUnfreeze(ds->pool);
ds->N = xrealloc(ds->N, (ds->Count+1) * sizeof(*ds->N));
if (u < ds->Count) {
memmove(ds->N + u + 1, ds->N + u,
(ds->Count - u) * sizeof(*ds->N));
}
ds->N[u] = rpmstrPoolId(ds->pool, rpmdsN(ods), 1);
ds->EVR = xrealloc(ds->EVR, (ds->Count+1) * sizeof(*ds->EVR));
if (u < ds->Count) {
memmove(ds->EVR + u + 1, ds->EVR + u,
(ds->Count - u) * sizeof(*ds->EVR));
}
OEVR = rpmdsEVR(ods);
ds->EVR[u] = rpmstrPoolId(ds->pool, OEVR ? OEVR : "", 1);
ds->Flags = xrealloc(ds->Flags, (ds->Count+1) * sizeof(*ds->Flags));
if (u < ds->Count) {
memmove(ds->Flags + u + 1, ds->Flags + u,
(ds->Count - u) * sizeof(*ds->Flags));
}
ds->Flags[u] = rpmdsFlags(ods);
if (ds->ti || ods->ti) {
ds->ti = xrealloc(ds->ti, (ds->Count+1) * sizeof(*ds->ti));
if (u < ds->Count) {
memmove(ds->ti + u + 1, ds->ti + u,
(ds->Count - u) * sizeof(*ds->ti));
}
ds->ti[u] = rpmdsTi(ods);
}
ds->i = ds->Count;
ds->Count++;
}
ods->i = save;
return (ds->Count - ocount);
}
static PyObject *
rpmds_Count(rpmdsObject * s)
{
return Py_BuildValue("i", rpmdsCount(s->ds));
}
static int
rpmds_length(rpmdsObject * s)
{
return rpmdsCount(s->ds);
}