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