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 "attr_store.h"
  19
  20 typedef struct _Repokey {
  21   Id name;
  22   Id type;
  23   Id size;
  24   Id storage;
  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 struct _Repo;
  33
  34 typedef struct _Repodata {
  35   struct _Repo *repo;           /* back pointer to repo */
  36
  37   int start;                    /* start of solvables this repodata is valid for */
  38   int end;                      /* last solvable + 1 of this repodata */
  39
  40   /* Keys provided by this attribute store, sorted by name value.
  41      The same keys may be provided by multiple attribute stores, but
  42      then only for different solvables.  I.e. the relation
  43        (solvable,name) -> store
  44      has to be injective.  */
  45
  46   Repokey *keys;                /* keys, first entry is always zero */
  47   unsigned int nkeys;           /* length of keys array */
  48
  49   Id *schemata;                 /* schema -> offset into schemadata */
  50   unsigned int nschemata;       /* number of schemata */
  51
  52   Id *schemadata;               /* schema storage */
  53
  54   unsigned char *entryschemau8; /* schema for entry */
  55   Id *entryschema;              /* schema for entry */
  56
  57   unsigned char *incoredata;    /* in-core data */
  58   unsigned int incoredatalen;   /* data len */
  59   unsigned int incoredatafree;  /* data len */
  60
  61   Id *incoreoffset;             /* offset for all entries */
  62
  63   FILE *fp;                     /* for paged access */
  64   Id verticaloffset;            /* offset of verticals */
  65
  66   char *strbuf;
  67   int strbuflen;
  68
  69
  70   /* The attribute store itself.  */
  71   Attrstore *s;
  72   /* A filename where to find this attribute store, or where to store
  73      it.  May be "", in which case we can't load it on demand or store
  74      into it.  It may also be NULL for at most one of the repodata per
  75      repo, in which case these are the embedded attributes.  */
  76
  77   const char *location;
  78   /* The SHA1 checksum of the file.  */
  79   unsigned char checksum[20];
  80 } Repodata;
  81
  82
  83 typedef struct _Repo {
  84   const char *name;
  85   struct _Pool *pool;           /* pool containing repo data */
  86
  87   int start;                    /* start of this repo solvables within pool->solvables */
  88   int end;                      /* last solvable + 1 of this repo */
  89   int nsolvables;               /* number of solvables repo is contributing to pool */
  90
  91   int priority;                 /* priority of this repo */
  92
  93   Id *idarraydata;              /* array of metadata Ids, solvable dependencies are offsets into this array */
  94   int idarraysize;
  95   Offset lastoff;
  96
  97   Id *rpmdbid;
  98
  99   /* The attribute stores we know about.  */
 100   Repodata *repodata;
 101   /* Number of attribute stores..  */
 102   unsigned nrepodata;
 103 } Repo;
 104
 105 extern Repo *repo_create(Pool *pool, const char *name);
 106 extern void repo_free(Repo *repo, int reuseids);
 107 extern void repo_freeallrepos(Pool *pool, int reuseids);
 108
 109 extern Offset repo_addid(Repo *repo, Offset olddeps, Id id);
 110 extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq);
 111 extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num);
 112 extern Offset repo_fix_legacy(Repo *repo, Offset provides, Offset supplements);
 113
 114 extern void repo_add_attrstore (Repo *repo, Attrstore *s, const char *location);
 115
 116 static inline const char *repo_name(const Repo *repo)
 117 {
 118   return repo->name;
 119 }
 120
 121 static inline Id repo_add_solvable(Repo *repo)
 122 {
 123   extern Id pool_add_solvable(Pool *pool);
 124   Id p = pool_add_solvable(repo->pool);
 125   if (!repo->start || repo->start == repo->end)
 126     {
 127       repo->start = p;
 128       repo->end = p + 1;
 129     }
 130   else
 131     {
 132       if (p < repo->start)
 133         repo->start = p;
 134       if (p + 1 > repo->end)
 135         repo->end = p + 1;
 136     }
 137   repo->nsolvables++;
 138   repo->pool->solvables[p].repo = repo;
 139   return p;
 140 }
 141
 142 static inline Id repo_add_solvable_block(Repo *repo, int count)
 143 {
 144   extern Id pool_add_solvable_block(Pool *pool, int count);
 145   Id p;
 146   Solvable *s;
 147   if (!count)
 148     return 0;
 149   p = pool_add_solvable_block(repo->pool, count);
 150   if (!repo->start || repo->start == repo->end)
 151     {
 152       repo->start = p;
 153       repo->end = p + count;
 154     }
 155   else
 156     {
 157       if (p < repo->start)
 158         repo->start = p;
 159       if (p + count > repo->end)
 160         repo->end = p + count;
 161     }
 162   repo->nsolvables += count;
 163   for (s = repo->pool->solvables + p; count--; s++)
 164     s->repo = repo;
 165   return p;
 166 }
 167
 168 static inline void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids)
 169 {
 170   extern void pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids);
 171   Solvable *s;
 172   int i;
 173   if (start + count == repo->end)
 174     repo->end -= count;
 175   repo->nsolvables -= count;
 176   for (s = repo->pool->solvables + start, i = count; i--; s++)
 177     s->repo = 0;
 178   pool_free_solvable_block(repo->pool, start, count, reuseids);
 179 }
 180
 181 #define FOR_REPO_SOLVABLES(r, p, s)                                             \
 182   for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s++)    \
 183     if (s->repo == (r))
 184
 185 #endif /* SATSOLVER_REPO_H */