X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frepo.h;h=b503431af7e5f3f3c2b03d7dcbef9ebffc2d639b;hb=6a68988035ea989055076d81b7ab53c7015c8c32;hp=2f7c49abda5cae656bd0a337216c5d9d8788d857;hpb=560f20469f373bc8779587b8692b9949f38fc4bb;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/repo.h b/src/repo.h index 2f7c49a..b503431 100644 --- a/src/repo.h +++ b/src/repo.h @@ -7,20 +7,25 @@ /* * repo.h - * + * */ -#ifndef SATSOLVER_REPO_H -#define SATSOLVER_REPO_H +#ifndef LIBSOLV_REPO_H +#define LIBSOLV_REPO_H #include "pooltypes.h" #include "pool.h" +#include "poolarch.h" #include "repodata.h" +#include "dataiterator.h" +#include "hash.h" +#ifdef __cplusplus +extern "C" { +#endif - -typedef struct _Repo { - const char *name; /* application private name pointer */ +typedef struct s_Repo { + const char *name; /* name pointer */ Id repoid; /* our id */ void *appdata; /* application private pointer */ @@ -36,96 +41,81 @@ typedef struct _Repo { Id *idarraydata; /* array of metadata Ids, solvable dependencies are offsets into this array */ int idarraysize; - Offset lastoff; /* start of last array in idarraydata */ - Id *rpmdbid; /* solvable side data */ + int nrepodata; /* number of our stores.. */ + + Id *rpmdbid; /* solvable side data: rpm database id */ +#ifdef LIBSOLV_INTERNAL Repodata *repodata; /* our stores for non-solvable related data */ - unsigned nrepodata; /* number of our stores.. */ + Offset lastoff; /* start of last array in idarraydata */ + + Hashtable lastidhash; /* hash to speed up repo_addid_dep */ + Hashval lastidhash_mask; + int lastidhash_idarraysize; + int lastmarker; + Offset lastmarkerpos; +#endif /* LIBSOLV_INTERNAL */ } Repo; extern Repo *repo_create(Pool *pool, const char *name); extern void repo_free(Repo *repo, int reuseids); -extern void repo_freeallrepos(Pool *pool, int reuseids); +extern void repo_empty(Repo *repo, int reuseids); +extern void repo_freedata(Repo *repo); +extern Id repo_add_solvable(Repo *repo); +extern Id repo_add_solvable_block(Repo *repo, int count); +extern void repo_free_solvable(Repo *repo, Id p, int reuseids); extern void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids); extern void *repo_sidedata_create(Repo *repo, size_t size); extern void *repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count); +extern Id repo_add_solvable_block_before(Repo *repo, int count, Repo *beforerepo); extern Offset repo_addid(Repo *repo, Offset olddeps, Id id); extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker); extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num); -extern Offset repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens); -extern Offset repo_fix_conflicts(Repo *repo, Offset conflicts); static inline const char *repo_name(const Repo *repo) { return repo->name; } -static inline Id repo_add_solvable(Repo *repo) +/* those two functions are here because they need the Repo definition */ + +static inline Repo *pool_id2repo(Pool *pool, Id repoid) { - extern Id pool_add_solvable(Pool *pool); - Id p = pool_add_solvable(repo->pool); - if (!repo->start || repo->start == repo->end) - repo->start = repo->end = p; - /* warning: sidedata must be extended before adapting start/end */ - if (repo->rpmdbid) - repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1); - if (p < repo->start) - repo->start = p; - if (p + 1 > repo->end) - repo->end = p + 1; - repo->nsolvables++; - repo->pool->solvables[p].repo = repo; - return p; + return repoid < pool->nrepos ? pool->repos[repoid] : 0; } -static inline Id repo_add_solvable_block(Repo *repo, int count) +static inline int pool_disabled_solvable(const Pool *pool, Solvable *s) { - extern Id pool_add_solvable_block(Pool *pool, int count); - Id p; - Solvable *s; - if (!count) - return 0; - p = pool_add_solvable_block(repo->pool, count); - if (!repo->start || repo->start == repo->end) - repo->start = repo->end = p; - /* warning: sidedata must be extended before adapting start/end */ - if (repo->rpmdbid) - repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, count); - if (p < repo->start) - repo->start = p; - if (p + count > repo->end) - repo->end = p + count; - repo->nsolvables += count; - for (s = repo->pool->solvables + p; count--; s++) - s->repo = repo; - return p; + if (s->repo && s->repo->disabled) + return 1; + if (pool->considered) + { + Id id = s - pool->solvables; + if (!MAPTST(pool->considered, id)) + return 1; + } + return 0; } - -#define FOR_REPO_SOLVABLES(r, p, s) \ - for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s = (r)->pool->solvables + p) \ - if (s->repo == (r)) - - -/* those two functions are here because they need the Repo definition */ - -static inline Repo *pool_id2repo(Pool *pool, Id repoid) +static inline int pool_badarch_solvable(const Pool *pool, Solvable *s) { - return pool->repos[repoid - 1]; + if (pool->id2arch && (!s->arch || pool_arch2score(pool, s->arch) == 0)) + return 1; + return 0; } static inline int pool_installable(const Pool *pool, Solvable *s) { - if (!s->arch || s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) + if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) return 0; if (s->repo && s->repo->disabled) return 0; - if (pool->id2arch && (s->arch > pool->lastarch || !pool->id2arch[s->arch])) + if (pool->id2arch && (!s->arch || pool_arch2score(pool, s->arch) == 0)) return 0; if (pool->considered) - { + { Id id = s - pool->solvables; if (!MAPTST(pool->considered, id)) return 0; @@ -133,185 +123,113 @@ static inline int pool_installable(const Pool *pool, Solvable *s) return 1; } -/* search callback values */ +#ifdef LIBSOLV_INTERNAL +static inline int pool_installable_whatprovides(const Pool *pool, Solvable *s) +{ + /* we always need the installed solvable in the whatprovides data, + otherwise obsoletes/conflicts on them won't work */ + if (s->repo != pool->installed) + { + if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC || pool_badarch_solvable(pool, s)) + return 0; + if (pool->considered && !pool->whatprovideswithdisabled) + { + Id id = s - pool->solvables; + if (!MAPTST(pool->considered, id)) + return 0; + } + } + return 1; +} +#endif +/* not in solvable.h because we need the repo definition */ +static inline Solvable *solvable_free(Solvable *s, int reuseids) +{ + if (s && s->repo) + repo_free_solvable(s->repo, s - s->repo->pool->solvables, reuseids); + return 0; +} + +/* search callback values */ #define SEARCH_NEXT_KEY 1 #define SEARCH_NEXT_SOLVABLE 2 #define SEARCH_STOP 3 #define SEARCH_ENTERSUB -1 -typedef struct _KeyValue { - Id id; - const char *str; - int num; - int num2; - - int entry; /* array entry, starts with 0 */ - int eof; /* last entry reached */ - - struct _KeyValue *parent; -} KeyValue; - -/* search matcher flags */ -#define SEARCH_STRINGMASK 15 -#define SEARCH_STRING 1 -#define SEARCH_SUBSTRING 2 -#define SEARCH_GLOB 3 -#define SEARCH_REGEX 4 -#define SEARCH_ERROR 5 -#define SEARCH_NOCASE (1<<7) - -/* iterator control */ -#define SEARCH_NO_STORAGE_SOLVABLE (1<<8) -#define SEARCH_SUB (1<<9) -#define SEARCH_ARRAYSENTINEL (1<<10) -#define SEARCH_DISABLED_REPOS (1<<11) -#define SEARCH_COMPLETE_FILELIST (1<<12) - -/* stringification flags */ -#define SEARCH_SKIP_KIND (1<<16) -/* By default we stringify just to the basename of a file because - the construction of the full filename is costly. Specify this - flag if you want to match full filenames */ -#define SEARCH_FILES (1<<17) -#define SEARCH_CHECKSUMS (1<<18) - -/* dataiterator internal */ -#define SEARCH_THISSOLVID (1<<31) - - /* standard flags used in the repo_add functions */ #define REPO_REUSE_REPODATA (1 << 0) #define REPO_NO_INTERNALIZE (1 << 1) #define REPO_LOCALPOOL (1 << 2) #define REPO_USE_LOADING (1 << 3) #define REPO_EXTEND_SOLVABLES (1 << 4) +#define REPO_USE_ROOTDIR (1 << 5) +#define REPO_NO_LOCATION (1 << 6) Repodata *repo_add_repodata(Repo *repo, int flags); +Repodata *repo_id2repodata(Repo *repo, Id id); Repodata *repo_last_repodata(Repo *repo); void repo_search(Repo *repo, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata); -/* returns the string value of the attribute, or NULL if not found */ -const char *repo_lookup_str(Repo *repo, Id entry, Id key); -/* returns the integer value of the attribute, or 0 if not found */ -unsigned int repo_lookup_num(Repo *repo, Id entry, Id key, unsigned int notfound); -Id repo_lookup_id(Repo *repo, Id entry, Id keyid); -int repo_lookup_void(Repo *repo, Id entry, Id keyid); -const unsigned char *repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyid, Id *typep); - -typedef struct _Datamatcher { - int flags; - const char *match; - void *matchdata; - int error; -} Datamatcher; - -typedef struct _Dataiterator -{ - int state; - int flags; - - Pool *pool; - Repo *repo; - Repodata *data; - - /* data pointers */ - unsigned char *dp; - unsigned char *ddp; - Id *idp; - Id *keyp; - - /* the result */ - Repokey *key; - KeyValue kv; - - /* our matcher */ - Datamatcher matcher; - - /* iterators/filters */ - Id keyname; - Id repodataid; - Id solvid; - Id repoid; - - Id keynames[3 + 1]; - int nkeynames; - int rootlevel; - - /* recursion data */ - struct di_parent { - KeyValue kv; - unsigned char *dp; - Id *keyp; - } parents[3]; - int nparents; - -} Dataiterator; - -int datamatcher_init(Datamatcher *ma, const char *match, int flags); -void datamatcher_free(Datamatcher *ma); -int datamatcher_match(Datamatcher *ma, const char *str); - -/* - * Dataiterator - * - * Iterator like interface to 'search' functionality - * - * Dataiterator is per-pool, additional filters can be applied - * to limit the search domain. See dataiterator_init below. - * - * Use these like: - * Dataiterator di; - * dataiterator_init(&di, repo->pool, repo, 0, 0, "bla", SEARCH_SUBSTRING); - * while (dataiterator_step(&di)) - * dosomething(di.solvid, di.key, di.kv); - * dataiterator_free(&di); - */ - -/* - * Initialize dataiterator - * - * di: Pointer to Dataiterator to be initialized - * pool: Search domain for the iterator - * repo: if non-null, limit search to this repo - * solvid: if non-null, limit search to this solvable - * keyname: if non-null, limit search to this keyname - * match: if non-null, limit search to this match - */ -int dataiterator_init(Dataiterator *di, Pool *pool, Repo *repo, Id p, Id keyname, const char *match, int flags); -void dataiterator_init_clone(Dataiterator *di, Dataiterator *from); -void dataiterator_set_search(Dataiterator *di, Repo *repo, Id p); -void dataiterator_set_keyname(Dataiterator *di, Id keyname); -int dataiterator_set_match(Dataiterator *di, const char *match, int flags); - -void dataiterator_prepend_keyname(Dataiterator *di, Id keyname); -void dataiterator_free(Dataiterator *di); -int dataiterator_step(Dataiterator *di); -void dataiterator_setpos(Dataiterator *di); -void dataiterator_setpos_parent(Dataiterator *di); -int dataiterator_match(Dataiterator *di, Datamatcher *ma); -void dataiterator_skip_attribute(Dataiterator *di); -void dataiterator_skip_solvable(Dataiterator *di); -void dataiterator_skip_repo(Dataiterator *di); -void dataiterator_jump_to_solvid(Dataiterator *di, Id solvid); -void dataiterator_jump_to_repo(Dataiterator *di, Repo *repo); -void dataiterator_entersub(Dataiterator *di); -void dataiterator_clonepos(Dataiterator *di, Dataiterator *from); -void dataiterator_seek(Dataiterator *di, int whence); - -#define DI_SEEK_STAY (1 << 16) -#define DI_SEEK_CHILD 1 -#define DI_SEEK_PARENT 2 -#define DI_SEEK_REWIND 3 +/* returns the last repodata that contains the key */ +Repodata *repo_lookup_repodata(Repo *repo, Id entry, Id keyname); +Repodata *repo_lookup_repodata_opt(Repo *repo, Id entry, Id keyname); +Repodata *repo_lookup_filelist_repodata(Repo *repo, Id entry, Datamatcher *matcher); +/* returns the string value of the attribute, or NULL if not found */ +Id repo_lookup_type(Repo *repo, Id entry, Id keyname); +const char *repo_lookup_str(Repo *repo, Id entry, Id keyname); +/* returns the integer value of the attribute, or notfound if not found */ +unsigned long long repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned long long notfound); +Id repo_lookup_id(Repo *repo, Id entry, Id keyname); +int repo_lookup_idarray(Repo *repo, Id entry, Id keyname, Queue *q); +int repo_lookup_deparray(Repo *repo, Id entry, Id keyname, Queue *q, Id marker); +int repo_lookup_void(Repo *repo, Id entry, Id keyname); +const char *repo_lookup_checksum(Repo *repo, Id entry, Id keyname, Id *typep); +const unsigned char *repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep); +const void *repo_lookup_binary(Repo *repo, Id entry, Id keyname, int *lenp); +unsigned int repo_lookup_count(Repo *repo, Id entry, Id keyname); /* internal */ +Id solv_depmarker(Id keyname, Id marker); void repo_set_id(Repo *repo, Id p, Id keyname, Id id); -void repo_set_num(Repo *repo, Id p, Id keyname, Id num); +void repo_set_num(Repo *repo, Id p, Id keyname, unsigned long long num); void repo_set_str(Repo *repo, Id p, Id keyname, const char *str); void repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str); void repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str); +void repo_add_idarray(Repo *repo, Id p, Id keyname, Id id); +void repo_add_deparray(Repo *repo, Id p, Id keyname, Id dep, Id marker); +void repo_set_idarray(Repo *repo, Id p, Id keyname, Queue *q); +void repo_set_deparray(Repo *repo, Id p, Id keyname, Queue *q, Id marker); +void repo_unset(Repo *repo, Id p, Id keyname); + void repo_internalize(Repo *repo); void repo_disable_paging(Repo *repo); +Id *repo_create_keyskip(Repo *repo, Id entry, Id **oldkeyskip); + + +/* iterator macros */ +#define FOR_REPO_SOLVABLES(r, p, s) \ + for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s = (r)->pool->solvables + p) \ + if (s->repo != (r)) \ + continue; \ + else + +#ifdef LIBSOLV_INTERNAL +#define FOR_REPODATAS(repo, rdid, data) \ + for (rdid = 1, data = repo->repodata + rdid; rdid < repo->nrepodata; rdid++, data++) +#else +#define FOR_REPODATAS(repo, rdid, data) \ + for (rdid = 1; rdid < repo->nrepodata && (data = repo_id2repodata(repo, rdid)); rdid++) +#endif + +/* weird suse stuff, do not use */ +extern Offset repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens); +extern Offset repo_fix_conflicts(Repo *repo, Offset conflicts); +extern void repo_rewrite_suse_deps(Solvable *s, Offset freshens); + +#ifdef __cplusplus +} +#endif -#endif /* SATSOLVER_REPO_H */ +#endif /* LIBSOLV_REPO_H */