rset/rsbetween.c

   1 /*
   2  * Copyright (C) 1994-2002, Index Data
   3  * All rights reserved.
   4  * Heikki Levanto
   5  *
   6  * $Id: rsbetween.c,v 1.2 2002-04-12 14:51:34 heikki Exp $
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <assert.h>
  13
  14 #include <rsbetween.h>
  15 #include <zebrautl.h>
  16
  17 static void *r_create_between(RSET ct, const struct rset_control *sel, void *parms);
  18 static RSFD r_open_between (RSET ct, int flag);
  19 static void r_close_between (RSFD rfd);
  20 static void r_delete_between (RSET ct);
  21 static void r_rewind_between (RSFD rfd);
  22 static int r_count_between (RSET ct);
  23 static int r_read_between (RSFD rfd, void *buf, int *term_index);
  24 static int r_write_between (RSFD rfd, const void *buf);
  25
  26 static const struct rset_control control_between =
  27 {
  28     "between",
  29     r_create_between,
  30     r_open_between,
  31     r_close_between,
  32     r_delete_between,
  33     r_rewind_between,
  34     r_count_between,
  35     r_read_between,
  36     r_write_between,
  37 };
  38
  39
  40 const struct rset_control *rset_kind_between = &control_between;
  41
  42 struct rset_between_info {
  43     int key_size;
  44     RSET rset_l;
  45     RSET rset_m;
  46     RSET rset_r;
  47     int term_index_s;
  48     int (*cmp)(const void *p1, const void *p2);
  49     char *(*printer)(void *p1, char *buf);
  50     struct rset_between_rfd *rfd_list;
  51 };
  52
  53 struct rset_between_rfd {
  54     RSFD rfd_l;
  55     RSFD rfd_m;
  56     RSFD rfd_r;
  57     int  more_l;
  58     int  more_m;
  59     int  more_r;
  60     int term_index_l;
  61     int term_index_m;
  62     int term_index_r;
  63     void *buf_l;
  64     void *buf_m;
  65     void *buf_r;
  66     int level;
  67     struct rset_between_rfd *next;
  68     struct rset_between_info *info;
  69 };
  70
  71 static void *r_create_between (RSET ct, const struct rset_control *sel, void *parms)
  72 {
  73     rset_between_parms *between_parms = (rset_between_parms *) parms;
  74     struct rset_between_info *info;
  75
  76     info = (struct rset_between_info *) xmalloc (sizeof(*info));
  77     info->key_size = between_parms->key_size;
  78     info->rset_l = between_parms->rset_l;
  79     info->rset_m = between_parms->rset_m;
  80     info->rset_r = between_parms->rset_r;
  81     if (rset_is_volatile(info->rset_l) ||
  82         rset_is_volatile(info->rset_m) ||
  83         rset_is_volatile(info->rset_r))
  84         ct->flags |= RSET_FLAG_VOLATILE;
  85     info->cmp = between_parms->cmp;
  86     info->printer = between_parms->printer;
  87     info->rfd_list = NULL;
  88
  89     info->term_index_s = info->rset_l->no_rset_terms;
  90     ct->no_rset_terms =
  91         info->rset_l->no_rset_terms +
  92         info->rset_m->no_rset_terms +
  93         info->rset_r->no_rset_terms;
  94     ct->rset_terms = (RSET_TERM *)
  95         xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
  96
  97     memcpy (ct->rset_terms, info->rset_l->rset_terms,
  98             info->rset_l->no_rset_terms * sizeof(*ct->rset_terms));
  99     memcpy (ct->rset_terms + info->rset_l->no_rset_terms,
 100             info->rset_m->rset_terms,
 101             info->rset_m->no_rset_terms * sizeof(*ct->rset_terms));
 102     memcpy (ct->rset_terms + info->rset_l->no_rset_terms +
 103                              info->rset_m->no_rset_terms,
 104             info->rset_r->rset_terms,
 105             info->rset_r->no_rset_terms * sizeof(*ct->rset_terms));
 106     return info;
 107 }
 108
 109 static RSFD r_open_between (RSET ct, int flag)
 110 {
 111     struct rset_between_info *info = (struct rset_between_info *) ct->buf;
 112     struct rset_between_rfd *rfd;
 113
 114     if (flag & RSETF_WRITE)
 115     {
 116         logf (LOG_FATAL, "between set type is read-only");
 117         return NULL;
 118     }
 119     rfd = (struct rset_between_rfd *) xmalloc (sizeof(*rfd));
 120     rfd->next = info->rfd_list;
 121     info->rfd_list = rfd;
 122     rfd->info = info;
 123
 124     rfd->buf_l = xmalloc (info->key_size);
 125     rfd->buf_m = xmalloc (info->key_size);
 126     rfd->buf_r = xmalloc (info->key_size);
 127     rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
 128     rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
 129     rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
 130     rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l,
 131                              &rfd->term_index_l);
 132     rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m,
 133                              &rfd->term_index_m);
 134     rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r,
 135                              &rfd->term_index_r);
 136     rfd->level=0;
 137     return rfd;
 138 }
 139
 140 static void r_close_between (RSFD rfd)
 141 {
 142     struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
 143     struct rset_between_rfd **rfdp;
 144
 145     for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
 146         if (*rfdp == rfd)
 147         {
 148             xfree ((*rfdp)->buf_l);
 149             xfree ((*rfdp)->buf_m);
 150             xfree ((*rfdp)->buf_r);
 151             rset_close (info->rset_l, (*rfdp)->rfd_l);
 152             rset_close (info->rset_m, (*rfdp)->rfd_m);
 153             rset_close (info->rset_r, (*rfdp)->rfd_r);
 154             *rfdp = (*rfdp)->next;
 155             xfree (rfd);
 156             return;
 157         }
 158     logf (LOG_FATAL, "r_close_between but no rfd match!");
 159     assert (0);
 160 }
 161
 162 static void r_delete_between (RSET ct)
 163 {
 164     struct rset_between_info *info = (struct rset_between_info *) ct->buf;
 165
 166     assert (info->rfd_list == NULL);
 167     xfree (ct->rset_terms);
 168     rset_delete (info->rset_l);
 169     rset_delete (info->rset_m);
 170     rset_delete (info->rset_r);
 171     xfree (info);
 172 }
 173
 174 static void r_rewind_between (RSFD rfd)
 175 {
 176     struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
 177     struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
 178
 179     logf (LOG_DEBUG, "rsbetween_rewind");
 180     rset_rewind (info->rset_l, p->rfd_l);
 181     rset_rewind (info->rset_m, p->rfd_m);
 182     rset_rewind (info->rset_r, p->rfd_r);
 183     p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l, &p->term_index_l);
 184     p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m, &p->term_index_m);
 185     p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r, &p->term_index_r);
 186     p->level=0;
 187 }
 188
 189 static int r_count_between (RSET ct)
 190 {
 191     return 0;
 192 }
 193
 194 static int r_read_between (RSFD rfd, void *buf, int *term_index)
 195 {
 196     struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
 197     struct rset_between_info *info = p->info;
 198     int cmp_l;
 199     int cmp_r;
 200
 201     while (p->more_m)
 202     {
 203
 204         /* forward L until past m, count levels, note rec boundaries */
 205         if (p->more_l)
 206             cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
 207         else
 208             cmp_l=2; /* past this record */
 209         while (cmp_l < 0)   /* l before m */
 210         {
 211             if (cmp_l == -2)
 212                 p->level=0; /* earlier record */
 213             if (cmp_l == -1)
 214                 p->level++; /* relevant start tag */
 215             if (p->more_l)
 216             {
 217                 p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
 218                                    &p->term_index_l);
 219                 cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
 220             }
 221             else
 222                 cmp_l=2;
 223         } /* forward L */
 224
 225         /* forward R until past m, count levels */
 226         if (p->more_r)
 227             cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 228         else
 229             cmp_r=2;
 230         while (cmp_r < 0)   /* r before m */
 231         {
 232             /* -2, earlier record, doesn't matter */
 233             if (cmp_r == -1)
 234                 p->level--; /* relevant end tag */
 235             if (p->more_r)
 236             {
 237                 p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
 238                                    &p->term_index_r);
 239                 cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 240             }
 241             else
 242                 cmp_r=2;
 243         } /* forward R */
 244
 245         if ( ( p->level <= 0 ) && ! p->more_l)
 246             return 0; /* no more start tags, nothing more to find */
 247
 248         if ( p->level > 0)  /* within a tag pair (or deeper) */
 249         {
 250             memcpy (buf, p->buf_m, info->key_size);
 251             *term_index = p->term_index_m;
 252             return 1;
 253         }
 254         else
 255             if ( ! p->more_l )  /* not in data, no more starts */
 256                 return 0;  /* ergo, nothing can be found. stop scanning */
 257
 258         p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
 259                                &p->term_index_m);
 260     } /* while more_m */
 261
 262     return 0;  /* no more data possible */
 263
 264 }  /* r_read */
 265
 266
 267 static int r_write_between (RSFD rfd, const void *buf)
 268 {
 269     logf (LOG_FATAL, "between set type is read-only");
 270     return -1;
 271 }
 272