Hci Work
[idzebra-moved-to-github.git] / rset / rssbool.c
1 /*
2  * Copyright (C) 1994-1995, Index Data I/S 
3  * All rights reserved.
4  * Sebastian Hammer, Adam Dickmeiss
5  *
6  * $Log: rssbool.c,v $
7  * Revision 1.1  1995-12-11 09:15:27  adam
8  * New set types: sand/sor/snot - ranked versions of and/or/not in
9  * ranked/semi-ranked result sets.
10  * Note: the snot not finished yet.
11  * New rset member: flag.
12  * Bug fix: r_delete in rsrel.c did free bad memory block.
13  *
14  */
15
16 #include <stdio.h>
17 #include <assert.h>
18
19 #include <rsbool.h>
20 #include <alexutil.h>
21
22 static void *r_create_and(const struct rset_control *sel, void *parms,
23                          int *flags);
24 static void *r_create_or(const struct rset_control *sel, void *parms,
25                          int *flags);
26 static void *r_create_not(const struct rset_control *sel, void *parms,
27                          int *flags);
28 static RSFD r_open (RSET ct, int flag);
29 static void r_close (RSFD rfd);
30 static void r_delete (RSET ct);
31 static void r_rewind (RSFD rfd);
32 static int r_count (RSET ct);
33 static int r_read (RSFD rfd, void *buf);
34 static int r_write (RSFD rfd, const void *buf);
35 static int r_score (RSFD rfd, int *score);
36
37 static const rset_control control_sand = 
38 {
39     "sand",
40     r_create_and,
41     r_open,
42     r_close,
43     r_delete,
44     r_rewind,
45     r_count,
46     r_read,
47     r_write,
48     r_score
49 };
50
51 static const rset_control control_sor = 
52 {
53     "sor",
54     r_create_or,
55     r_open,
56     r_close,
57     r_delete,
58     r_rewind,
59     r_count,
60     r_read,
61     r_write,
62     r_score
63 };
64
65 static const rset_control control_snot = 
66 {
67     "snot",
68     r_create_not,
69     r_open,
70     r_close,
71     r_delete,
72     r_rewind,
73     r_count,
74     r_read,
75     r_write,
76     r_score
77 };
78
79
80 const rset_control *rset_kind_sand = &control_sand;
81 const rset_control *rset_kind_sor = &control_sor;
82 const rset_control *rset_kind_snot = &control_snot;
83
84 struct rset_bool_info {
85     int key_size;
86     RSET rset_l;
87     RSET rset_r;
88     char *key_buf;
89     int *score_buf;
90     int key_no;
91     int key_max;
92     int (*cmp)(const void *p1, const void *p2);
93     struct rset_bool_rfd *rfd_list;
94 };
95
96 struct rset_bool_rfd {
97     struct rset_bool_rfd *next;
98     struct rset_bool_info *info;
99     int position;
100     int last_pos;
101     int open_flag;
102 };    
103
104 static void *r_create_common (const struct rset_control *sel, 
105                               rset_bool_parms *bool_parms, int *flags);
106             
107 static void key_add (struct rset_bool_info *info,
108                      char *buf, int score)
109 {
110     if (info->key_no == info->key_max)
111         return;
112     memcpy (info->key_buf + info->key_size * info->key_no,
113             buf, info->key_size);
114     info->score_buf[info->key_no] = score;
115     (info->key_no)++;
116 }
117
118 static void *r_create_and (const struct rset_control *sel, void *parms,
119                            int *flags)
120 {
121     int more_l, more_r;
122     RSFD fd_l, fd_r;
123     char *buf_l, *buf_r;
124
125     struct rset_bool_info *info;
126     info = r_create_common (sel, parms, flags);
127
128     buf_l = xmalloc (info->key_size);
129     buf_r = xmalloc (info->key_size);
130     fd_l = rset_open (info->rset_l, RSETF_SORT_SYSNO|RSETF_READ);
131     fd_r = rset_open (info->rset_r, RSETF_SORT_SYSNO|RSETF_READ);
132
133     more_l = rset_read(info->rset_l, fd_l, buf_l);
134     more_r = rset_read(info->rset_r, fd_r, buf_r);
135
136     while (more_l || more_r)
137     {
138         int cmp;
139         int score, score_l, score_r;
140
141         if (more_l && more_r)
142             cmp = (*info->cmp)(buf_l, buf_r);
143         else if (more_r)
144             cmp = 2;
145         else 
146             cmp = -2;
147
148         if (cmp >= -1 && cmp <= 1)
149         {
150             rset_score (info->rset_l, fd_l, &score_l);
151             rset_score (info->rset_r, fd_r, &score_r);
152             if (score_l == -1)
153                 score = score_r;
154             else if (score_r == -1)
155                 score = score_l;
156             else
157                 score = score_l > score_r ? score_r : score_l;
158             key_add (info, buf_l, score);
159     
160             more_l = rset_read (info->rset_l, fd_l, buf_l);
161             more_r = rset_read (info->rset_r, fd_r, buf_r);
162         }
163         else if (cmp > 1)
164         {
165             rset_score (info->rset_r, fd_r, &score_r);
166             if (score_r != -1)
167                 key_add (info, buf_r, 1);
168             more_r = rset_read (info->rset_r, fd_r, buf_r);
169         }
170         else
171         {
172             rset_score (info->rset_l, fd_l, &score_l);
173             if (score_l != -1)
174                 key_add (info, buf_l, 1);
175             more_l = rset_read (info->rset_l, fd_l, buf_l);
176         }
177     }
178     rset_close (info->rset_l, fd_l);
179     rset_close (info->rset_r, fd_r);
180     rset_delete (info->rset_l);
181     rset_delete (info->rset_r);
182     xfree (buf_l);
183     xfree (buf_r);
184     return info;
185 }
186
187 static void *r_create_or (const struct rset_control *sel, void *parms,
188                           int *flags)
189 {
190     int more_l, more_r;
191     RSFD fd_l, fd_r;
192     char *buf_l, *buf_r;
193
194     struct rset_bool_info *info;
195     info = r_create_common (sel, parms, flags);
196
197     buf_l = xmalloc (info->key_size);
198     buf_r = xmalloc (info->key_size);
199     fd_l = rset_open (info->rset_l, RSETF_SORT_SYSNO|RSETF_READ);
200     fd_r = rset_open (info->rset_r, RSETF_SORT_SYSNO|RSETF_READ);
201
202     more_l = rset_read(info->rset_l, fd_l, buf_l);
203     more_r = rset_read(info->rset_r, fd_r, buf_r);
204
205     while (more_l || more_r)
206     {
207         int cmp;
208         int score, score_l, score_r;
209
210         if (more_l && more_r)
211             cmp = (*info->cmp)(buf_l, buf_r);
212         else if (more_r)
213             cmp = 2;
214         else 
215             cmp = -2;
216
217         if (cmp >= -1 && cmp <= 1)
218         {
219             rset_score (info->rset_l, fd_l, &score_l);
220             rset_score (info->rset_r, fd_r, &score_r);
221             if (score_l == -1)
222                 score = score_r;
223             else if (score_r == -1)
224                 score = score_l;
225             else
226                 score = score_r > score_l ? score_r : score_l;
227             key_add (info, buf_l, score);
228     
229             more_l = rset_read (info->rset_l, fd_l, buf_l);
230             more_r = rset_read (info->rset_r, fd_r, buf_r);
231         }
232         else if (cmp > 1)
233         {
234             rset_score (info->rset_r, fd_r, &score_r);
235             if (score_r != -1)
236                 key_add (info, buf_r, score_r / 2);
237             more_r = rset_read (info->rset_r, fd_r, buf_r);
238         }
239         else
240         {
241             rset_score (info->rset_l, fd_l, &score_l);
242             if (score_l != -1)
243                 key_add (info, buf_l, score_l / 2);
244             more_l = rset_read (info->rset_l, fd_l, buf_l);
245         }
246     }
247     rset_close (info->rset_l, fd_l);
248     rset_close (info->rset_r, fd_r);
249     rset_delete (info->rset_l);
250     rset_delete (info->rset_r);
251     xfree (buf_l);
252     xfree (buf_r);
253     return info;
254 }
255
256 static void *r_create_not (const struct rset_control *sel, void *parms,
257                            int *flags)
258 {
259     char *buf_l, *buf_r;
260
261     struct rset_bool_info *info;
262     info = r_create_common (sel, parms, flags);
263
264     buf_l = xmalloc (info->key_size);
265     buf_r = xmalloc (info->key_size);
266     rset_delete (info->rset_l);
267     rset_delete (info->rset_r);
268     xfree (buf_l);
269     xfree (buf_r);
270     return info;
271 }
272
273 static void *r_create_common (const struct rset_control *sel, 
274                               rset_bool_parms *bool_parms, int *flags)
275 {
276     struct rset_bool_info *info;
277
278     info = xmalloc (sizeof(*info));
279     info->key_size = bool_parms->key_size;
280     info->rset_l = bool_parms->rset_l;
281     info->rset_r = bool_parms->rset_r;
282     info->cmp = bool_parms->cmp;
283     info->rfd_list = NULL;
284     
285     if (rset_is_ranked(info->rset_l) || rset_is_ranked(info->rset_r))
286         *flags |= RSET_FLAG_RANKED;
287
288     info->key_max = rset_count(bool_parms->rset_l)
289                    +rset_count(bool_parms->rset_r);
290     if (!info->key_max)
291         info->key_max = 1;
292     if (info->key_max > 1000)
293         info->key_max = 1000;
294     info->key_buf = xmalloc (info->key_size * info->key_max);
295     info->score_buf = xmalloc (info->key_max * sizeof(*info->score_buf));
296     info->key_no = 0;
297
298     return info;
299 }
300
301 static RSFD r_open (RSET ct, int flag)
302 {
303     struct rset_bool_info *info = ct->buf;
304     struct rset_bool_rfd *rfd;
305
306     if (flag & RSETF_WRITE)
307     {
308         logf (LOG_FATAL, "sbool set type is read-only");
309         return NULL;
310     }
311     rfd = xmalloc (sizeof(*rfd));
312     rfd->next = info->rfd_list;
313     info->rfd_list = rfd;
314     rfd->info = info;
315
316     rfd->position = 0;
317     rfd->last_pos = 0;
318     rfd->open_flag = flag;
319
320     return rfd;
321 }
322
323 static void r_close (RSFD rfd)
324 {
325     struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
326     struct rset_bool_rfd **rfdp;
327     
328     for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
329         if (*rfdp == rfd)
330         {
331             *rfdp = (*rfdp)->next;
332             xfree (rfd);
333             return;
334         }
335     logf (LOG_FATAL, "r_close but no rfd match!");
336     assert (0);
337 }
338
339 static void r_delete (RSET ct)
340 {
341     struct rset_bool_info *info = ct->buf;
342
343     assert (info->rfd_list == NULL);
344     xfree (info->score_buf);
345     xfree (info->key_buf);
346     xfree (info);
347 }
348
349 static void r_rewind (RSFD rfd)
350 {
351     struct rset_bool_rfd *p = rfd;
352
353     logf (LOG_DEBUG, "rsbool_rewind");
354     p->position = p->last_pos = 0;
355 }
356
357 static int r_count (RSET ct)
358 {
359     struct rset_bool_info *info = ct->buf;
360
361     return info->key_no;
362 }
363
364 static int r_read (RSFD rfd, void *buf)
365 {
366     struct rset_bool_rfd *p = rfd;
367     struct rset_bool_info *info = p->info;
368
369     if (p->position >= info->key_no)
370         return 0;
371     p->last_pos = (p->position)++;
372     memcpy (buf, info->key_buf + info->key_size * p->last_pos,
373             info->key_size);
374     return 1;
375 }
376
377 static int r_write (RSFD rfd, const void *buf)
378 {
379     logf (LOG_FATAL, "sbool set type is read-only");
380     return -1;
381 }
382
383 static int r_score (RSFD rfd, int *score)
384 {
385     struct rset_bool_rfd *p = rfd;
386     struct rset_bool_info *info = p->info;
387
388     *score = info->score_buf[p->last_pos];
389     return 1;
390 }
391