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;                  /* solvable side data */
  48
  49   Repodata *repodata;           /* our stores for non-solvable related data */
  50   unsigned nrepodata;           /* number of our stores..  */
  51 } Repo;
  52
  53 extern Repo *repo_create(Pool *pool, const char *name);
  54 extern void repo_free(Repo *repo, int reuseids);
  55 extern void repo_freeallrepos(Pool *pool, int reuseids);
  56 extern void *repo_sidedata_create(Repo *repo, size_t size);
  57 extern void *repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count);
  58
  59 extern Offset repo_addid(Repo *repo, Offset olddeps, Id id);
  60 extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker);
  61 extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num);
  62 extern Offset repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens);
  63 extern Offset repo_fix_conflicts(Repo *repo, Offset conflicts);
  64
  65 static inline const char *repo_name(const Repo *repo)
  66 {
  67   return repo->name;
  68 }
  69
  70 static inline Id repo_add_solvable(Repo *repo)
  71 {
  72   extern Id pool_add_solvable(Pool *pool);
  73   Id p = pool_add_solvable(repo->pool);
  74   if (!repo->start || repo->start == repo->end)
  75     {
  76       repo->start = p;
  77       repo->end = p + 1;
  78     }
  79   else
  80     {
  81       if (repo->rpmdbid)
  82         repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1);
  83       if (p < repo->start)
  84         repo->start = p;
  85       if (p + 1 > repo->end)
  86         repo->end = p + 1;
  87     }
  88   repo->nsolvables++;
  89   repo->pool->solvables[p].repo = repo;
  90   return p;
  91 }
  92
  93 static inline Id repo_add_solvable_block(Repo *repo, int count)
  94 {
  95   extern Id pool_add_solvable_block(Pool *pool, int count);
  96   Id p;
  97   Solvable *s;
  98   if (!count)
  99     return 0;
 100   p = pool_add_solvable_block(repo->pool, count);
 101   if (!repo->start || repo->start == repo->end)
 102     {
 103       repo->start = p;
 104       repo->end = p + count;
 105     }
 106   else
 107     {
 108       if (repo->rpmdbid)
 109         repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, count);
 110       if (p < repo->start)
 111         repo->start = p;
 112       if (p + count > repo->end)
 113         repo->end = p + count;
 114     }
 115   repo->nsolvables += count;
 116   for (s = repo->pool->solvables + p; count--; s++)
 117     s->repo = repo;
 118   return p;
 119 }
 120
 121 static inline void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids)
 122 {
 123   extern void pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids);
 124   Solvable *s;
 125   int i;
 126   if (start + count == repo->end)
 127     repo->end -= count;
 128   repo->nsolvables -= count;
 129   for (s = repo->pool->solvables + start, i = count; i--; s++)
 130     s->repo = 0;
 131   pool_free_solvable_block(repo->pool, start, count, reuseids);
 132 }
 133
 134 #define FOR_REPO_SOLVABLES(r, p, s)                                             \
 135   for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s = (r)->pool->solvables + p)   \
 136     if (s->repo == (r))
 137
 138
 139 /* search callback values */
 140
 141 #define SEARCH_NEXT_KEY         1
 142 #define SEARCH_NEXT_SOLVABLE    2
 143 #define SEARCH_STOP             3
 144 #define SEARCH_ENTERSUB         -1
 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_ARRAYSENTINEL            (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_THISSOLVID               (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   int flags;
 227   void *match;
 228   int error;
 229 } Datamatcher;
 230
 231 typedef struct _Dataiterator
 232 {
 233   int state;
 234   int flags;
 235
 236   Pool *pool;
 237   Repo *repo;
 238   Repodata *data;
 239
 240   /* data pointers */
 241   unsigned char *dp;
 242   unsigned char *ddp;
 243   Id *idp;
 244   Id *keyp;
 245
 246   /* the result */
 247   Repokey *key;
 248   KeyValue kv;
 249
 250   /* our matcher */
 251   Datamatcher matcher;
 252
 253   /* iterators/filters */
 254   Id keyname;
 255   Id repodataid;
 256   Id solvid;
 257   Id repoid;
 258
 259   /* recursion data */
 260   struct di_parent {
 261     KeyValue kv;
 262     unsigned char *dp;
 263     Id *keyp;
 264   } parents[3];
 265   int nparents;
 266   Id keynames[3 + 1];
 267   int nkeynames;
 268
 269 } Dataiterator;
 270
 271 #endif
 272
 273 int datamatcher_init(Datamatcher *ma, const char *match, int flags);
 274 void datamatcher_free(Datamatcher *ma);
 275 int datamatcher_match(Datamatcher *ma, const char *str);
 276
 277 /* Use these like:
 278      Dataiterator di;
 279      dataiterator_init(&di, repo->pool, repo, 0, 0, "bla", SEARCH_SUBSTRING);
 280      while (dataiterator_step(&di))
 281        dosomething(di.solvid, di.key, di.kv);
 282      dataiterator_free(&di);    */
 283 int dataiterator_init(Dataiterator *di, Pool *pool, Repo *repo, Id p, Id keyname,
 284                        const char *match, int flags);
 285 void dataiterator_prepend_keyname(Dataiterator *di, Id keyname);
 286 void dataiterator_free(Dataiterator *di);
 287 int dataiterator_step(Dataiterator *di);
 288 void dataiterator_setpos(Dataiterator *di);
 289 void dataiterator_setpos_parent(Dataiterator *di);
 290 int dataiterator_match(Dataiterator *di, Datamatcher *ma);
 291 void dataiterator_skip_attribute(Dataiterator *di);
 292 void dataiterator_skip_solvable(Dataiterator *di);
 293 void dataiterator_skip_repo(Dataiterator *di);
 294 void dataiterator_jump_to_solvid(Dataiterator *di, Id solvid);
 295 void dataiterator_jump_to_repo(Dataiterator *di, Repo *repo);
 296 void dataiterator_entersub(Dataiterator *di);
 297
 298 /* to be removed ... */
 299 int dataiterator_match_obsolete(Dataiterator *di, int flags, const void *match);
 300
 301 void repo_set_id(Repo *repo, Id p, Id keyname, Id id);
 302 void repo_set_num(Repo *repo, Id p, Id keyname, Id num);
 303 void repo_set_str(Repo *repo, Id p, Id keyname, const char *str);
 304 void repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str);
 305 void repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str);
 306 void repo_internalize(Repo *repo);
 307 void repo_disable_paging(Repo *repo);
 308
 309 #endif /* SATSOLVER_REPO_H */