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