src/repo.h

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * repo.h
  10  *
  11  */
  12
  13 #ifndef SATSOLVER_REPO_H
  14 #define SATSOLVER_REPO_H
  15
  16 #include "pooltypes.h"
  17 #include "pool.h"
  18 #include "repodata.h"
  19
  20 typedef struct _Repokey {
  21   Id name;
  22   Id type;               /* REPOKEY_TYPE_xxx */
  23   unsigned int size;
  24   unsigned int storage; /* KEY_STORAGE_xxx */
  25 } Repokey;
  26
  27 #define KEY_STORAGE_DROPPED             0
  28 #define KEY_STORAGE_SOLVABLE            1
  29 #define KEY_STORAGE_INCORE              2
  30 #define KEY_STORAGE_VERTICAL_OFFSET     3
  31
  32
  33 typedef struct _Repo {
  34   const char *name;
  35   struct _Pool *pool;           /* pool containing repo data */
  36
  37   int start;                    /* start of this repo solvables within pool->solvables */
  38   int end;                      /* last solvable + 1 of this repo */
  39   int nsolvables;               /* number of solvables repo is contributing to pool */
  40
  41   int priority;                 /* priority of this repo */
  42
  43   Id *idarraydata;              /* array of metadata Ids, solvable dependencies are offsets into this array */
  44   int idarraysize;
  45   Offset lastoff;
  46
  47   Id *rpmdbid;                  /* hmm, go to repodata? */
  48   unsigned char rpmdbcookie[32];
  49
  50   Repodata *repodata;           /* our stores for non-solvable related data */
  51   unsigned nrepodata;           /* number of our stores..  */
  52 } Repo;
  53
  54 extern Repo *repo_create(Pool *pool, const char *name);
  55 extern void repo_free(Repo *repo, int reuseids);
  56 extern void repo_freeallrepos(Pool *pool, int reuseids);
  57 extern void *repo_sidedata_create(Repo *repo, size_t size);
  58 extern void *repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count);
  59
  60 extern Offset repo_addid(Repo *repo, Offset olddeps, Id id);
  61 extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker);
  62 extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num);
  63 extern Offset repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens);
  64 extern Offset repo_fix_conflicts(Repo *repo, Offset conflicts);
  65
  66 static inline const char *repo_name(const Repo *repo)
  67 {
  68   return repo->name;
  69 }
  70
  71 static inline Id repo_add_solvable(Repo *repo)
  72 {
  73   extern Id pool_add_solvable(Pool *pool);
  74   Id p = pool_add_solvable(repo->pool);
  75   if (!repo->start || repo->start == repo->end)
  76     {
  77       repo->start = p;
  78       repo->end = p + 1;
  79     }
  80   else
  81     {
  82       if (repo->rpmdbid)
  83         repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1);
  84       if (p < repo->start)
  85         repo->start = p;
  86       if (p + 1 > repo->end)
  87         repo->end = p + 1;
  88     }
  89   repo->nsolvables++;
  90   repo->pool->solvables[p].repo = repo;
  91   return p;
  92 }
  93
  94 static inline Id repo_add_solvable_block(Repo *repo, int count)
  95 {
  96   extern Id pool_add_solvable_block(Pool *pool, int count);
  97   Id p;
  98   Solvable *s;
  99   if (!count)
 100     return 0;
 101   p = pool_add_solvable_block(repo->pool, count);
 102   if (!repo->start || repo->start == repo->end)
 103     {
 104       repo->start = p;
 105       repo->end = p + count;
 106     }
 107   else
 108     {
 109       if (repo->rpmdbid)
 110         repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, count);
 111       if (p < repo->start)
 112         repo->start = p;
 113       if (p + count > repo->end)
 114         repo->end = p + count;
 115     }
 116   repo->nsolvables += count;
 117   for (s = repo->pool->solvables + p; count--; s++)
 118     s->repo = repo;
 119   return p;
 120 }
 121
 122 static inline void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids)
 123 {
 124   extern void pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids);
 125   Solvable *s;
 126   int i;
 127   if (start + count == repo->end)
 128     repo->end -= count;
 129   repo->nsolvables -= count;
 130   for (s = repo->pool->solvables + start, i = count; i--; s++)
 131     s->repo = 0;
 132   pool_free_solvable_block(repo->pool, start, count, reuseids);
 133 }
 134
 135 #define FOR_REPO_SOLVABLES(r, p, s)                                             \
 136   for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s = (r)->pool->solvables + p)   \
 137     if (s->repo == (r))
 138
 139
 140 /* search callback values */
 141
 142 #define SEARCH_NEXT_KEY         1
 143 #define SEARCH_NEXT_SOLVABLE    2
 144 #define SEARCH_STOP             3
 145
 146 typedef struct _KeyValue {
 147   Id id;
 148   const char *str;
 149   int num;
 150   int num2;
 151
 152   int entry;    /* array entry, starts with 0 */
 153   int eof;      /* last entry reached */
 154
 155   struct _KeyValue *parent;
 156 } KeyValue;
 157
 158 /* search flags */
 159 #define SEARCH_STRINGMASK       15
 160 #define SEARCH_STRING           1
 161 #define SEARCH_SUBSTRING        2
 162 #define SEARCH_GLOB             3
 163 #define SEARCH_REGEX            4
 164 #define SEARCH_ERROR            5
 165
 166 #define SEARCH_NOCASE                   (1<<8)
 167 #define SEARCH_NO_STORAGE_SOLVABLE      (1<<9)
 168 #define SEARCH_SUB                      (1<<10)
 169 #define SEARCH_ALL_REPOS                (1<<11)
 170 #define SEARCH_SKIP_KIND                (1<<12)
 171
 172
 173 /* By default we don't match in attributes representing filelists
 174    because the construction of those strings is costly.  Specify this
 175    flag if you want this.  In that case kv->str will contain the full
 176    filename (if matched of course).  */
 177 #define SEARCH_FILES                    (1<<13)
 178
 179 /* Internal */
 180 #define SEARCH_THISENTRY                (1<<31)
 181
 182
 183 /* standard flags used in the repo_add functions */
 184 #define REPO_REUSE_REPODATA             (1 << 0)
 185 #define REPO_NO_INTERNALIZE             (1 << 1)
 186
 187 Repodata *repo_add_repodata(Repo *repo, int localpool);
 188 Repodata *repo_last_repodata(Repo *repo);
 189
 190 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);
 191
 192 /* returns the string value of the attribute, or NULL if not found */
 193 const char *repo_lookup_str(Repo *repo, Id entry, Id key);
 194 /* returns the integer value of the attribute, or 0 if not found */
 195 unsigned int repo_lookup_num(Repo *repo, Id entry, Id key, unsigned int notfound);
 196 Id repo_lookup_id(Repo *repo, Id entry, Id keyid);
 197 int repo_lookup_void(Repo *repo, Id entry, Id keyid);
 198 const unsigned char *repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyid, Id *typep);
 199
 200
 201 #if 0
 202 typedef struct _Dataiterator
 203 {
 204   Repodata *data;
 205   Id *keyp;
 206   unsigned char *nextkeydp;
 207   unsigned char *dp;
 208   Repokey *key;
 209   Repo *repo;
 210   Id *idp;
 211   const char *match;
 212   Id solvid;
 213   Id keyname;
 214   unsigned flags;
 215   unsigned state;
 216   KeyValue kv;
 217   regex_t regex;
 218   int regex_err;
 219   Id *subkeyp;
 220   int subnum;
 221   Id subschema;
 222 } Dataiterator;
 223 #else
 224
 225 typedef struct _Datamatcher {
 226   Pool *pool;
 227   int flags;
 228   void *match;
 229   int error;
 230 } Datamatcher;
 231
 232 typedef struct _Dataiterator
 233 {
 234   int state;
 235   int flags;
 236
 237   Pool *pool;
 238   Repo *repo;
 239   Repodata *data;
 240
 241   /* data pointers */
 242   unsigned char *dp;
 243   unsigned char *ddp;
 244   Id *idp;
 245   Id *keyp;
 246
 247   /* the result */
 248   Repokey *key;
 249   KeyValue kv;
 250
 251   /* our matcher */
 252   Datamatcher matcher;
 253
 254   /* iterators/filters */
 255   Id keyname;
 256   Id repodataid;
 257   Id entry;
 258   Id repoid;
 259
 260   /* recursion data */
 261   struct di_parent {
 262     KeyValue kv;
 263     unsigned char *dp;
 264     Id *keyp;
 265   } parents[3];
 266   int nparents;
 267 } Dataiterator;
 268
 269 #endif
 270
 271 void datamatcher_init(Datamatcher *ma, Pool *pool, const char *match, int flags);
 272 void datamatcher_free(Datamatcher *ma);
 273 int datamatcher_match(Datamatcher *ma, Repodata *data, Repokey *key, KeyValue *kv);
 274
 275 /* Use these like:
 276      Dataiterator di;
 277      dataiterator_init(&di, repo, 0, 0, "bla", SEARCH_SUBSTRING);
 278      while (dataiterator_step(&di))
 279        dosomething(di.solvid, di.key, di.kv);
 280      dataiterator_free(&di);    */
 281 void dataiterator_init(Dataiterator *di, Repo *repo, Id p, Id keyname,
 282                        const char *match, int flags);
 283 void dataiterator_free(Dataiterator *di);
 284 int dataiterator_step(Dataiterator *di);
 285 void dataiterator_setpos(Dataiterator *di);
 286 int dataiterator_match(Dataiterator *di, int flags, const void *match);
 287 void dataiterator_skip_attribute(Dataiterator *di);
 288 void dataiterator_skip_solvable(Dataiterator *di);
 289 void dataiterator_skip_repo(Dataiterator *di);
 290 void dataiterator_jump_to_solvable(Dataiterator *di, Solvable *s);
 291 void dataiterator_jump_to_repo(Dataiterator *di, Repo *repo);
 292
 293 /* to be removed ... */
 294 int dataiterator_match(Dataiterator *di, int flags, const void *match);
 295
 296 void repo_set_id(Repo *repo, Id p, Id keyname, Id id);
 297 void repo_set_num(Repo *repo, Id p, Id keyname, Id num);
 298 void repo_set_str(Repo *repo, Id p, Id keyname, const char *str);
 299 void repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str);
 300 void repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str);
 301 void repo_internalize(Repo *repo);
 302 void repo_disable_paging(Repo *repo);
 303
 304 #endif /* SATSOLVER_REPO_H */