rset/rset.c

   1 /* $Id: rset.c,v 1.33 2004-09-09 10:08:06 heikki Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
   3    Index Data Aps
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <zebrautl.h>
  28 #include <assert.h>
  29 #include <yaz/nmem.h>
  30 #include <rset.h>
  31
  32
  33 /* creates an rfd. Either allocates a new one, in which case the priv */
  34 /* pointer is null, and will have to be filled in, or picks up one */
  35 /* from the freelist, in which case the priv is already allocated, */
  36 /* and presumably everything that hangs from it as well */
  37
  38 RSFD rfd_create_base(RSET rs)
  39 {
  40     RSFD rnew=rs->free_list;
  41     if (rnew) {
  42         rs->free_list=rnew->next;
  43         assert(rnew->rset==rs);
  44   /*    logf(LOG_DEBUG,"rfd-create_base (fl): rfd=%p rs=%p fl=%p priv=%p",
  45                        rnew, rs, rs->free_list, rnew->priv); */
  46     } else {
  47         rnew=nmem_malloc(rs->nmem, sizeof(*rnew));
  48         rnew->priv=NULL;
  49         rnew->rset=rs;
  50   /*    logf(LOG_DEBUG,"rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p",
  51                        rnew, rs, rs->free_list, rnew->priv); */
  52     }
  53     rnew->next=NULL; /* not part of any (free?) list */
  54     return rnew;
  55 }
  56
  57 /* puts an rfd into the freelist of the rset. Only when the rset gets */
  58 /* deleted, will all the nmem disappear */
  59 void rfd_delete_base(RSFD rfd)
  60 {
  61     RSET rs=rfd->rset;
  62  /* logf(LOG_DEBUG,"rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p",
  63             rfd, rs, rfd->priv, rs->free_list); */
  64     assert(NULL == rfd->next);
  65     rfd->next=rs->free_list;
  66     rs->free_list=rfd;
  67 }
  68
  69
  70 RSET rset_create_base(const struct rset_control *sel,
  71                       NMEM nmem, const struct key_control *kcontrol,
  72                       int scope)
  73 {
  74     RSET rnew;
  75     NMEM M;
  76     /* assert(nmem); */ /* can not yet be used, api/t4 fails */
  77     if (nmem)
  78         M=nmem;
  79     else
  80         M=nmem_create();
  81     rnew = (RSET) nmem_malloc(M,sizeof(*rnew));
  82  /* logf (LOG_DEBUG, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rnew, nmem); */
  83     rnew->nmem=M;
  84     if (nmem)
  85         rnew->my_nmem=0;
  86     else
  87         rnew->my_nmem=1;
  88     rnew->control = sel;
  89     rnew->count = 1;
  90     rnew->priv = 0;
  91     rnew->free_list=NULL;
  92     rnew->keycontrol=kcontrol;
  93     rnew->scope=scope;
  94     return rnew;
  95 }
  96
  97 void rset_delete (RSET rs)
  98 {
  99     (rs->count)--;
 100 /*  logf(LOG_DEBUG,"rs_delete(%s), rs=%p, count=%d",
 101             rs->control->desc, rs, rs->count); */
 102     if (!rs->count)
 103     {
 104         (*rs->control->f_delete)(rs);
 105         if (rs->my_nmem)
 106             nmem_destroy(rs->nmem);
 107     }
 108 }
 109
 110 RSET rset_dup (RSET rs)
 111 {
 112     (rs->count)++;
 113     return rs;
 114 }
 115
 116 #if 0
 117 void rset_default_pos (RSFD rfd, double *current, double *total)
 118 { /* This should never really be needed, but it is still used in */
 119   /* those rsets that we don't really plan to use, like isam-s */
 120     assert(rfd);
 121     assert(current);
 122     assert(total);
 123     *current=-1; /* signal that pos is not implemented */
 124     *total=-1;
 125 } /* rset_default_pos */
 126 #endif
 127
 128 int rset_default_forward(RSFD rfd, void *buf,
 129                            const void *untilbuf)
 130 {
 131     int more=1;
 132     int cmp=rfd->rset->scope;
 133     logf (LOG_DEBUG, "rset_default_forward starting '%s' (ct=%p rfd=%p)",
 134                     rfd->rset->control->desc, rfd->rset, rfd);
 135     /* key_logdump(LOG_DEBUG, untilbuf); */
 136     while ( (cmp>=rfd->rset->scope) && (more))
 137     {
 138         logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
 139         more=rset_read(rfd, buf);
 140         if (more)
 141             cmp=(rfd->rset->keycontrol->cmp)(untilbuf,buf);
 142 /*        if (more)
 143             key_logdump(LOG_DEBUG,buf); */
 144     }
 145     logf (LOG_DEBUG, "rset_default_forward exiting m=%d c=%d",more,cmp);
 146
 147     return more;
 148 }
 149