- add repodata_write and repo_empty functions
[platform/upstream/libsolv.git] / 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
21
22 typedef struct _Repo {
23   const char *name;             /* name pointer */
24   Id repoid;                    /* our id */
25   void *appdata;                /* application private pointer */
26
27   Pool *pool;                   /* pool containing this repo */
28
29   int start;                    /* start of this repo solvables within pool->solvables */
30   int end;                      /* last solvable + 1 of this repo */
31   int nsolvables;               /* number of solvables repo is contributing to pool */
32
33   int disabled;                 /* ignore the solvables? */
34   int priority;                 /* priority of this repo */
35   int subpriority;              /* sub-priority of this repo, used just for sorting, not pruning */
36
37   Id *idarraydata;              /* array of metadata Ids, solvable dependencies are offsets into this array */
38   int idarraysize;
39   Offset lastoff;               /* start of last array in idarraydata */
40
41   Id *rpmdbid;                  /* solvable side data */
42
43   Repodata *repodata;           /* our stores for non-solvable related data */
44   unsigned nrepodata;           /* number of our stores..  */
45 } Repo;
46
47 extern Repo *repo_create(Pool *pool, const char *name);
48 extern void repo_free(Repo *repo, int reuseids);
49 extern void repo_empty(Repo *repo, int reuseids);
50 extern void repo_freeallrepos(Pool *pool, int reuseids);
51 extern void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids);
52 extern void *repo_sidedata_create(Repo *repo, size_t size);
53 extern void *repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count);
54
55 extern Offset repo_addid(Repo *repo, Offset olddeps, Id id);
56 extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker);
57 extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num);
58 extern Offset repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens);
59 extern Offset repo_fix_conflicts(Repo *repo, Offset conflicts);
60
61 static inline const char *repo_name(const Repo *repo)
62 {
63   return repo->name;
64 }
65
66 static inline Id repo_add_solvable(Repo *repo)
67 {
68   extern Id pool_add_solvable(Pool *pool);
69   Id p = pool_add_solvable(repo->pool);
70   if (!repo->start || repo->start == repo->end)
71     repo->start = repo->end = p;
72   /* warning: sidedata must be extended before adapting start/end */
73   if (repo->rpmdbid)
74     repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1);
75   if (p < repo->start)
76     repo->start = p;
77   if (p + 1 > repo->end)
78     repo->end = p + 1;
79   repo->nsolvables++;
80   repo->pool->solvables[p].repo = repo;
81   return p;
82 }
83
84 static inline Id repo_add_solvable_block(Repo *repo, int count)
85 {
86   extern Id pool_add_solvable_block(Pool *pool, int count);
87   Id p;
88   Solvable *s;
89   if (!count)
90     return 0;
91   p = pool_add_solvable_block(repo->pool, count);
92   if (!repo->start || repo->start == repo->end)
93     repo->start = repo->end = p;
94   /* warning: sidedata must be extended before adapting start/end */
95   if (repo->rpmdbid)
96     repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, count);
97   if (p < repo->start)
98     repo->start = p;
99   if (p + count > repo->end)
100     repo->end = p + count;
101   repo->nsolvables += count;
102   for (s = repo->pool->solvables + p; count--; s++)
103     s->repo = repo;
104   return p;
105 }
106
107
108 #define FOR_REPO_SOLVABLES(r, p, s)                                             \
109   for (p = (r)->start, s = (r)->pool->solvables + p; p < (r)->end; p++, s = (r)->pool->solvables + p)   \
110     if (s->repo == (r))
111
112
113 /* those two functions are here because they need the Repo definition */
114
115 static inline Repo *pool_id2repo(Pool *pool, Id repoid)
116 {
117   return pool->repos[repoid - 1];
118 }
119
120 static inline int pool_installable(const Pool *pool, Solvable *s)
121 {
122   if (!s->arch || s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
123     return 0;
124   if (s->repo && s->repo->disabled)
125     return 0;
126   if (pool->id2arch && (s->arch > pool->lastarch || !pool->id2arch[s->arch]))
127     return 0;
128   if (pool->considered)
129     { 
130       Id id = s - pool->solvables;
131       if (!MAPTST(pool->considered, id))
132         return 0;
133     }
134   return 1;
135 }
136
137 /* search callback values */
138
139 #define SEARCH_NEXT_KEY         1
140 #define SEARCH_NEXT_SOLVABLE    2
141 #define SEARCH_STOP             3
142 #define SEARCH_ENTERSUB         -1
143
144 typedef struct _KeyValue {
145   Id id;
146   const char *str;
147   int num;
148   int num2;
149
150   int entry;    /* array entry, starts with 0 */
151   int eof;      /* last entry reached */
152
153   struct _KeyValue *parent;
154 } KeyValue;
155
156 /* search matcher flags */
157 #define SEARCH_STRINGMASK               15
158 #define SEARCH_STRING                   1
159 #define SEARCH_STRINGSTART              2
160 #define SEARCH_STRINGEND                3
161 #define SEARCH_SUBSTRING                4
162 #define SEARCH_GLOB                     5
163 #define SEARCH_REGEX                    6
164 #define SEARCH_ERROR                    15
165 #define SEARCH_NOCASE                   (1<<7)
166
167 /* iterator control */
168 #define SEARCH_NO_STORAGE_SOLVABLE      (1<<8)
169 #define SEARCH_SUB                      (1<<9)
170 #define SEARCH_ARRAYSENTINEL            (1<<10)
171 #define SEARCH_DISABLED_REPOS           (1<<11)
172 #define SEARCH_COMPLETE_FILELIST        (1<<12)
173
174 /* stringification flags */
175 #define SEARCH_SKIP_KIND                (1<<16)
176 /* By default we stringify just to the basename of a file because
177    the construction of the full filename is costly.  Specify this
178    flag if you want to match full filenames */
179 #define SEARCH_FILES                    (1<<17)
180 #define SEARCH_CHECKSUMS                (1<<18)
181
182 /* dataiterator internal */
183 #define SEARCH_THISSOLVID               (1<<31)
184
185
186 /* standard flags used in the repo_add functions */
187 #define REPO_REUSE_REPODATA             (1 << 0)
188 #define REPO_NO_INTERNALIZE             (1 << 1)
189 #define REPO_LOCALPOOL                  (1 << 2)
190 #define REPO_USE_LOADING                (1 << 3)
191 #define REPO_EXTEND_SOLVABLES           (1 << 4)
192
193 Repodata *repo_add_repodata(Repo *repo, int flags);
194 Repodata *repo_last_repodata(Repo *repo);
195
196 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);
197
198 /* returns the string value of the attribute, or NULL if not found */
199 const char *repo_lookup_str(Repo *repo, Id entry, Id key);
200 /* returns the integer value of the attribute, or 0 if not found */
201 unsigned int repo_lookup_num(Repo *repo, Id entry, Id key, unsigned int notfound);
202 Id repo_lookup_id(Repo *repo, Id entry, Id keyid);
203 int repo_lookup_void(Repo *repo, Id entry, Id keyid);
204 const unsigned char *repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyid, Id *typep);
205
206 typedef struct _Datamatcher {
207   int flags;
208   const char *match;
209   void *matchdata;
210   int error;
211 } Datamatcher;
212
213 typedef struct _Dataiterator
214 {
215   int state;
216   int flags;
217
218   Pool *pool;
219   Repo *repo;
220   Repodata *data;
221
222   /* data pointers */
223   unsigned char *dp;
224   unsigned char *ddp;
225   Id *idp;
226   Id *keyp;
227
228   /* the result */
229   Repokey *key;
230   KeyValue kv;
231
232   /* our matcher */
233   Datamatcher matcher;
234
235   /* iterators/filters */
236   Id keyname;
237   Id repodataid;
238   Id solvid;
239   Id repoid;
240
241   Id keynames[3 + 1];
242   int nkeynames;
243   int rootlevel;
244
245   /* recursion data */
246   struct di_parent {
247     KeyValue kv;
248     unsigned char *dp;
249     Id *keyp;
250   } parents[3];
251   int nparents;
252
253 } Dataiterator;
254
255 int datamatcher_init(Datamatcher *ma, const char *match, int flags);
256 void datamatcher_free(Datamatcher *ma);
257 int datamatcher_match(Datamatcher *ma, const char *str);
258
259 /*
260  * Dataiterator
261  * 
262  * Iterator like interface to 'search' functionality
263  * 
264  * Dataiterator is per-pool, additional filters can be applied
265  * to limit the search domain. See dataiterator_init below.
266  * 
267  * Use these like:
268  *    Dataiterator di;
269  *    dataiterator_init(&di, repo->pool, repo, 0, 0, "bla", SEARCH_SUBSTRING);
270  *    while (dataiterator_step(&di))
271  *      dosomething(di.solvid, di.key, di.kv);
272  *    dataiterator_free(&di);
273  */
274
275 /*
276  * Initialize dataiterator
277  * 
278  * di:      Pointer to Dataiterator to be initialized
279  * pool:    Search domain for the iterator
280  * repo:    if non-null, limit search to this repo
281  * solvid:  if non-null, limit search to this solvable
282  * keyname: if non-null, limit search to this keyname
283  * match:   if non-null, limit search to this match
284  */
285 int dataiterator_init(Dataiterator *di, Pool *pool, Repo *repo, Id p, Id keyname, const char *match, int flags);
286 void dataiterator_init_clone(Dataiterator *di, Dataiterator *from);
287 void dataiterator_set_search(Dataiterator *di, Repo *repo, Id p);
288 void dataiterator_set_keyname(Dataiterator *di, Id keyname);
289 int dataiterator_set_match(Dataiterator *di, const char *match, int flags);
290
291 void dataiterator_prepend_keyname(Dataiterator *di, Id keyname);
292 void dataiterator_free(Dataiterator *di);
293 int dataiterator_step(Dataiterator *di);
294 void dataiterator_setpos(Dataiterator *di);
295 void dataiterator_setpos_parent(Dataiterator *di);
296 int dataiterator_match(Dataiterator *di, Datamatcher *ma);
297 void dataiterator_skip_attribute(Dataiterator *di);
298 void dataiterator_skip_solvable(Dataiterator *di);
299 void dataiterator_skip_repo(Dataiterator *di);
300 void dataiterator_jump_to_solvid(Dataiterator *di, Id solvid);
301 void dataiterator_jump_to_repo(Dataiterator *di, Repo *repo);
302 void dataiterator_entersub(Dataiterator *di);
303 void dataiterator_clonepos(Dataiterator *di, Dataiterator *from);
304 void dataiterator_seek(Dataiterator *di, int whence);
305
306 #define DI_SEEK_STAY    (1 << 16)
307 #define DI_SEEK_CHILD   1
308 #define DI_SEEK_PARENT  2
309 #define DI_SEEK_REWIND  3
310
311
312 void repo_set_id(Repo *repo, Id p, Id keyname, Id id);
313 void repo_set_num(Repo *repo, Id p, Id keyname, Id num);
314 void repo_set_str(Repo *repo, Id p, Id keyname, const char *str);
315 void repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str);
316 void repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str);
317 void repo_internalize(Repo *repo);
318 void repo_disable_paging(Repo *repo);
319
320 #endif /* SATSOLVER_REPO_H */