-/* $Id: rset.h,v 1.31 2004-08-24 14:25:15 heikki Exp $
+/* $Id: rset.h,v 1.32 2004-08-31 10:43:35 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
extern "C" {
#endif
-typedef void *RSFD; /* Rset "file descriptor" */
-typedef struct rset *RSET;
+typedef struct rsfd *RSFD; /* Rset "file descriptor" */
+typedef struct rset *RSET; /* Result set */
+
+struct rsfd { /* the stuff common to all rsfd's. */
+ RSET rset; /* ptr to the rset this FD is opened to */
+ void *priv; /* private parameters for this type */
+ RSFD next; /* to keep lists of used/free rsfd's */
+};
+
struct rset_control
{
char *desc; /* text description of set type (for debugging) */
-/* void *(*f_create)(RSET ct, const struct rset_control *sel, void *parms); */
+/* RSET rs_something_create(const struct rset_control *sel, ...); */
+ void (*f_delete)(RSET ct);
RSFD (*f_open)(RSET ct, int wflag);
void (*f_close)(RSFD rfd);
- void (*f_delete)(RSET ct);
void (*f_rewind)(RSFD rfd);
- int (*f_forward)(RSET ct, RSFD rfd, void *buf,
+ int (*f_forward)(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
void (*f_pos)(RSFD rfd, double *current, double *total);
int (*f_write)(RSFD rfd, const void *buf);
};
-int rset_default_forward(RSET ct, RSFD rfd, void *buf,
+int rset_default_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
-void rset_default_pos(RSFD rfd, double *current, double *total);
typedef struct rset
NMEM nmem; /* nibble memory for various allocs */
char my_nmem; /* Should the nmem be destroyed with the rset? */
/* 1 if created with it, 0 if passed from above */
+ RSFD free_list; /* all rfd's allocated but not currently in use */
} rset;
/* rset is a "virtual base class", which will never exist on its own */
/* all instances are rsets of some specific type, like rsisamb, or rsbool */
/* They keep their own stuff behind the priv pointer. */
-#define RSETF_READ 0
-#define RSETF_WRITE 1
+RSFD rfd_create_base(RSET rs);
+void rfd_delete_base(RSFD rfd);
RSET rset_create_base(const struct rset_control *sel, NMEM nmem);
-
-RSET rset_create_OLD(const struct rset_control *sel, void *parms);
-/* parameters? */
-
void rset_delete(RSET rs);
-
RSET rset_dup (RSET rs);
+#define RSETF_READ 0
+#define RSETF_WRITE 1
/* RSFD rset_open(RSET rs, int wflag); */
#define rset_open(rs, wflag) (*(rs)->control->f_open)((rs), (wflag))
-/* void rset_close(RSET rs); */
-#define rset_close(rs, rfd) (*(rs)->control->f_close)(rfd)
+/* void rset_close(RSFD rfd); */
+#define rset_close(rfd) (*(rfd)->rset->control->f_close)(rfd)
-/* void rset_rewind(RSET rs); */
-#define rset_rewind(rs, rfd) (*(rs)->control->f_rewind)((rfd))
+/* void rset_rewind(RSFD rfd); */
+#define rset_rewind(rfd) (*(rfd)->rset->control->f_rewind)((rfd))
-/* int rset_forward(RSET rs, void *buf, void *untilbuf); */
-#define rset_forward(rs, fd, buf, cmpfunc, untilbuf) \
- (*(rs)->control->f_forward)((rs), (fd), (buf), (cmpfunc), (untilbuf))
+/* int rset_forward(RSFD rfd, void *buf, void *untilbuf); */
+#define rset_forward(rfd, buf, cmpfunc, untilbuf) \
+ (*(rfd)->rset->control->f_forward)((rfd),(buf),(cmpfunc),(untilbuf))
+/*FIXME - get rid of the cmp function here, keep it in a general */
+/* key_control block */
-/* int rset_pos(RSET rs, RSFD fd, double *current, double *total); */
-#define rset_pos(rs,fd,cur,tot) \
- (*(rs)->control->f_pos)( (fd),(cur),(tot))
+/* int rset_pos(RSFD fd, double *current, double *total); */
+#define rset_pos(rfd,cur,tot) \
+ (*(rfd)->rset->control->f_pos)( (rfd),(cur),(tot))
-/* int rset_read(RSET rs, void *buf); */
-#define rset_read(rs, fd, buf) (*(rs)->control->f_read)((fd), (buf))
+/* int rset_read(RSFD rfd, void *buf); */
+#define rset_read(rfd, buf) (*(rfd)->rset->control->f_read)((rfd), (buf))
-/* int rset_write(RSET rs, const void *buf); */
-#define rset_write(rs, fd, buf) (*(rs)->control->f_write)((fd), (buf))
+/* int rset_write(RSFD rfd, const void *buf); */
+#define rset_write(rfd, buf) (*(rfd)->rset->control->f_write)((rfd), (buf))
/* int rset_type (RSET) */
#define rset_type(rs) ((rs)->control->desc)
-/* $Id: trunc.c,v 1.39 2004-08-25 09:18:06 adam Exp $
+/* $Id: trunc.c,v 1.40 2004-08-31 10:43:35 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
for (i = rscur; --i >= 0; )
{
rsfd[i] = rset_open (rset[i], RSETF_READ);
- if (rset_read (rset[i], rsfd[i], ti->tmpbuf))
+ if (rset_read(rsfd[i], ti->tmpbuf))
heap_insert (ti, ti->tmpbuf, i);
else
{
- rset_close (rset[i], rsfd[i]);
+ rset_close (rsfd[i]);
rset_delete (rset[i]);
}
}
{
int n = ti->indx[ti->ptr[1]];
- rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+ rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
nn++;
while (1)
{
- if (!rset_read (rset[n], rsfd[n], ti->tmpbuf))
+ if (!rset_read (rsfd[n], ti->tmpbuf))
{
heap_delete (ti);
- rset_close (rset[n], rsfd[n]);
+ rset_close (rsfd[n]);
rset_delete (rset[n]);
break;
}
{
int n = ti->indx[ti->ptr[1]];
- rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+ rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
nn++;
if (preserve_position)
{
{
int n = ti->indx[ti->ptr[1]];
- rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+ rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
nn++;
while (1)
{
{
int n = ti->indx[ti->ptr[1]];
- rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+ rset_write (result_rsfd, ti->heap[ti->ptr[1]]);
nn++;
if (preserve_position)
else
logf (LOG_WARN, "Unknown isam set in rset_trunc_r");
- rset_close (result, result_rsfd);
+ rset_close (result_rsfd);
return result;
}
-/* $Id: zrpn.c,v 1.146 2004-08-30 12:32:24 heikki Exp $
+/* $Id: zrpn.c,v 1.147 2004-08-31 10:43:35 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
if (key.sysno <= 0)
key.sysno = 1;
#endif
- rset_write (result, rsfd, &key);
- rset_close (result, rsfd);
+ rset_write (rsfd, &key);
+ rset_close (rsfd);
return result;
}
*count = 0;
rfd = rset_open (r, RSETF_READ);
- while (rset_read (r, rfd, &key))
+ while (rset_read (rfd, &key))
{
#if IT_KEY_NEW
if (key.mem[0] != psysno)
#endif
kno++;
}
- rset_close (r, rfd);
+ rset_close (rfd);
logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
}
-/* $Id: zsets.c,v 1.58 2004-08-30 12:32:24 heikki Exp $
+/* $Id: zsets.c,v 1.59 2004-08-31 10:43:35 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
while (num_i < num && positions[num_i] < position)
num_i++;
rfd = rset_open (rset, RSETF_READ);
- while (num_i < num && rset_read (rset, rfd, &key))
+ while (num_i < num && rset_read (rfd, &key))
{
#if IT_KEY_NEW
zint this_sys = key.mem[0];
}
}
}
- rset_close (rset, rfd);
+ rset_close (rfd);
}
}
return sr;
}
}
rfd = rset_open (rset, RSETF_READ);
- while (rset_read (rset, rfd, &key))
+ while (rset_read (rfd, &key))
{
#if IT_KEY_NEW
zint this_sys = key.mem[0];
sort_criteria, num_criteria, psysno);
}
}
- rset_close (rset, rfd);
+ rset_close (rfd);
#if 0
for (i = 0; i < rset->no_rset_terms; i++)
}
rc = rank_class->control;
- if (rset_read (rset, rfd, &key))
+ if (rset_read (rfd, &key))
{
#if IT_KEY_NEW
zint psysno = key.mem[0];
if ( (est==-2) && (zebraSet->hits==esthits))
{ /* time to estimate the hits */
- rset_pos(rset,rfd,&cur,&tot);
+ rset_pos(rfd,&cur,&tot);
if (tot>0) {
ratio=cur/tot;
est=(zint)(0.5+zebraSet->hits/ratio);
}
}
}
- while (rset_read (rset, rfd, &key) && (est<0) );
+ while (rset_read (rfd, &key) && (est<0) );
score = (*rc->calc) (handle, psysno);
resultSetInsertRank (zh, sort_info, psysno, score, 'A');
(*rc->end) (zh->reg, handle);
}
- rset_close (rset, rfd);
+ rset_close (rfd);
/*
for (i = 0; i < rset->no_rset_terms; i++)
{
-/* $Id: rsbetween.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsbetween.c,v 1.23 2004-08-31 10:43:36 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_close_between (RSFD rfd);
static void r_delete_between (RSET ct);
static void r_rewind_between (RSFD rfd);
-static int r_forward_between(RSET ct, RSFD rfd, void *buf,
+static int r_forward_between(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static int r_read_between (RSFD rfd, void *buf);
static const struct rset_control control =
{
"between",
+ r_delete_between,
r_open_between,
r_close_between,
- r_delete_between,
r_rewind_between,
r_forward_between, /* rset_default_forward, */
r_pos_between,
RSET rset_attr;
int (*cmp)(const void *p1, const void *p2);
char *(*printer)(const void *p1, char *buf);
- struct rset_between_rfd *rfd_list;
- struct rset_between_rfd *free_list;
};
struct rset_between_rfd {
info->rset_attr = rset_attr;
info->cmp = cmp;
info->printer = printer;
- info->rfd_list = NULL;
- info->free_list = NULL;
rnew->priv=info;
return rnew;
{
struct rset_between_info *info = (struct rset_between_info *) ct->priv;
- assert (info->rfd_list == NULL);
rset_delete (info->rset_l);
rset_delete (info->rset_m);
rset_delete (info->rset_r);
static RSFD r_open_between (RSET ct, int flag)
{
struct rset_between_info *info = (struct rset_between_info *) ct->priv;
- struct rset_between_rfd *rfd;
+ RSFD rfd;
+ struct rset_between_rfd *p;
if (flag & RSETF_WRITE)
{
logf (LOG_FATAL, "between set type is read-only");
return NULL;
}
- rfd=info->free_list;
- if (rfd)
- info->free_list=rfd->next;
+ rfd=rfd_create_base(ct);
+ if (rfd->priv)
+ p=(struct rset_between_rfd *)rfd->priv;
else {
- rfd = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*rfd)));
- rfd->buf_l = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_m = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_r = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
+ p = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*p)));
+ rfd->priv=p;
+ p->buf_l = nmem_malloc(ct->nmem, (info->key_size));
+ p->buf_m = nmem_malloc(ct->nmem, (info->key_size));
+ p->buf_r = nmem_malloc(ct->nmem, (info->key_size));
+ p->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
}
- rfd->next = info->rfd_list;
- info->rfd_list = rfd;
- rfd->info = info;
- rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
- rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
- rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
+ p->rfd_l = rset_open (info->rset_l, RSETF_READ);
+ p->rfd_m = rset_open (info->rset_m, RSETF_READ);
+ p->rfd_r = rset_open (info->rset_r, RSETF_READ);
- rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
- rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m);
- rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_m = rset_read (p->rfd_m, p->buf_m);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
if (info->rset_attr)
{
- rfd->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
- rfd->more_attr = rset_read (info->rset_attr, rfd->rfd_attr,
- rfd->buf_attr);
+ p->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
+ p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
}
- rfd->level=0;
- rfd->hits=0;
+ p->level=0;
+ p->hits=0;
return rfd;
}
static void r_close_between (RSFD rfd)
{
- struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
- struct rset_between_rfd **rfdp;
-
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- struct rset_between_rfd *rfd_tmp=*rfdp;
- rset_close (info->rset_l, (*rfdp)->rfd_l);
- rset_close (info->rset_m, (*rfdp)->rfd_m);
- rset_close (info->rset_r, (*rfdp)->rfd_r);
- if (info->rset_attr)
- rset_close (info->rset_attr, (*rfdp)->rfd_attr);
- *rfdp = (*rfdp)->next;
- rfd_tmp->next=info->free_list;
- info->free_list=rfd_tmp;
- return;
- }
- logf (LOG_FATAL, "r_close_between but no rfd match!");
- assert (0);
+ struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+ struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
+
+ rset_close (p->rfd_l);
+ rset_close (p->rfd_m);
+ rset_close (p->rfd_r);
+ if (info->rset_attr)
+ rset_close (p->rfd_attr);
+ rfd_delete_base(rfd);
}
static void r_rewind_between (RSFD rfd)
{
- struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
- struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
+ struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+ struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
#if RSBETWEEN_DEBUG
logf (LOG_DEBUG, "rsbetween_rewind");
#endif
- rset_rewind (info->rset_l, p->rfd_l);
- rset_rewind (info->rset_m, p->rfd_m);
- rset_rewind (info->rset_r, p->rfd_r);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ rset_rewind (p->rfd_l);
+ rset_rewind (p->rfd_m);
+ rset_rewind (p->rfd_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_m = rset_read (p->rfd_m, p->buf_m);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
if (info->rset_attr)
{
- rset_rewind (info->rset_attr, p->rfd_attr);
- p->more_attr = rset_read (info->rset_attr, p->rfd_attr, p->buf_attr);
+ rset_rewind (p->rfd_attr);
+ p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
}
p->level=0;
p->hits=0;
-static int r_forward_between(RSET ct, RSFD rfd, void *buf,
+static int r_forward_between(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
- struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
- struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
+ struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+ struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
int rc;
#if RSBETWEEN_DEBUG
log2( p, "fwd: before forward", 0,0);
/* It is enough to forward the m pointer here, the read will */
/* naturally forward the l, m, and attr pointers */
if (p->more_m)
- p->more_m=rset_forward(info->rset_m,p->rfd_m, p->buf_m,
+ p->more_m=rset_forward(p->rfd_m, p->buf_m,
info->cmp,untilbuf);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward M", 0,0);
static int r_read_between (RSFD rfd, void *buf)
{
- struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
- struct rset_between_info *info = p->info;
+ struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
+ struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
int cmp_l=0;
int cmp_r=0;
int attr_match = 0;
else if (cmp_attr > 0)
break;
else if (cmp_attr==-1)
- p->more_attr = rset_read (info->rset_attr,
- p->rfd_attr, p->buf_attr);
+ p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
/* if we had a forward that went all the way to
* the seqno, we could use that. But fwd only goes
* to the sysno */
else if (cmp_attr==-2)
{
- p->more_attr = rset_forward(
- info->rset_attr, p->rfd_attr,
+ p->more_attr = rset_forward( p->rfd_attr,
p->buf_attr, info->cmp, p->buf_l);
#if RSBETWEEN_DEBUG
logf(LOG_DEBUG, "btw: after frowarding attr m=%d",p->more_attr);
{
if (p->more_l)
{
- p->more_l=rset_forward( info->rset_l, p->rfd_l,
+ p->more_l=rset_forward(p->rfd_l,
p->buf_l, info->cmp, p->buf_m);
if (p->more_l)
cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
}
} else
{
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
}
#else
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
#endif
if (p->more_l)
{
#if NEWCODE
if (cmp_r==-2)
{
- p->more_r=rset_forward( info->rset_r, p->rfd_r,
+ p->more_r=rset_forward(p->rfd_r,
p->buf_r, info->cmp, p->buf_m);
} else
{
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
}
if (p->more_r)
cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
#else
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
#endif
}
#if RSBETWEEN_DEBUG
log2( p, "Returning a hit (and forwarding m)", cmp_l, cmp_r);
#endif
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+ p->more_m = rset_read (p->rfd_m, p->buf_m);
if (cmp_l == 2)
p->level = 0;
p->hits++;
if (cmp_l == 2)
{
p->level = 0;
- p->more_m=rset_forward( info->rset_m, p->rfd_m,
+ p->more_m=rset_forward(p->rfd_m,
p->buf_m, info->cmp, p->buf_l);
} else
{
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+ p->more_m = rset_read (p->rfd_m, p->buf_m);
}
#else
if (cmp_l == 2)
p->level = 0;
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+ p->more_m = rset_read (p->rfd_m, p->buf_m);
#endif
#if RSBETWEEN_DEBUG
log2( p, "End of M loop", cmp_l, cmp_r);
static void r_pos_between (RSFD rfd, double *current, double *total)
{
- struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
- struct rset_between_info *info = p->info;
+ struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
double lcur,ltot;
double mcur,mtot;
double rcur,rtot;
double r;
ltot=-1; rtot=-1;
- rset_pos(info->rset_l, p->rfd_l, &lcur, <ot);
- rset_pos(info->rset_m, p->rfd_m, &mcur, &mtot);
- rset_pos(info->rset_r, p->rfd_r, &rcur, &rtot);
+ rset_pos(p->rfd_l, &lcur, <ot);
+ rset_pos(p->rfd_m, &mcur, &mtot);
+ rset_pos(p->rfd_r, &rcur, &rtot);
if ( (ltot<0) && (mtot<0) && (rtot<0) ) { /*no position */
*current=mcur; /* return same as you got */
*total=mtot; /* probably -1 for not available */
-/* $Id: rsbool.c,v 1.44 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsbool.c,v 1.45 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
static const struct rset_control control_and =
{
"and",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward,
r_pos,
static const struct rset_control control_or =
{
"or",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward,
r_pos,
static const struct rset_control control_not =
{
"not",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward,
r_pos,
RSET rset_r;
int (*cmp)(const void *p1, const void *p2);
void (*log_item)(int logmask, const void *p, const char *txt);
- struct rset_bool_rfd *rfd_list; /* RSFDs in use */
- struct rset_bool_rfd *free_list; /* RSFDs that are freed (for reuse) */
};
struct rset_bool_rfd {
info->rset_r = rset_r;
info->cmp = cmp;
info->log_item = log_item;
- info->rfd_list = NULL;
- info->free_list = NULL;
rnew->priv=info;
return rnew;
static void r_delete (RSET ct)
{
struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
-
- assert (info->rfd_list == NULL);
rset_delete (info->rset_l);
rset_delete (info->rset_r);
}
-#if 0
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_bool_parms *bool_parms = (rset_bool_parms *) parms;
- struct rset_bool_info *info;
-
- info = (struct rset_bool_info *) xmalloc (sizeof(*info));
- info->key_size = bool_parms->key_size;
- info->rset_l = bool_parms->rset_l;
- info->rset_r = bool_parms->rset_r;
- info->cmp = bool_parms->cmp;
- info->log_item = bool_parms->log_item;
- info->rfd_list = NULL;
-
- return info;
-}
-#endif
static RSFD r_open (RSET ct, int flag)
{
struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
- struct rset_bool_rfd *rfd;
+ RSFD rfd;
+ struct rset_bool_rfd *p;
+
if (flag & RSETF_WRITE)
{
logf (LOG_FATAL, "bool set type is read-only");
return NULL;
}
- rfd = info->free_list;
- if (rfd)
- info->free_list = rfd->next;
+ rfd = rfd_create_base(ct);
+ if (rfd->priv)
+ p=(struct rset_bool_rfd *)rfd->priv;
else {
- rfd = (struct rset_bool_rfd *) nmem_malloc(ct->nmem, sizeof(*rfd));
- rfd->buf_l = nmem_malloc(ct->nmem, info->key_size);
- rfd->buf_r = nmem_malloc(ct->nmem, info->key_size);
+ p=nmem_malloc(ct->nmem,sizeof(*p));
+ rfd->priv=p;
+ p->buf_l = nmem_malloc(ct->nmem, info->key_size);
+ p->buf_r = nmem_malloc(ct->nmem, info->key_size);
}
logf(LOG_DEBUG,"rsbool (%s) open [%p]", ct->control->desc, rfd);
- rfd->next = info->rfd_list;
- info->rfd_list = rfd;
- rfd->info = info;
- rfd->hits=0;
-
- rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
- rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
- rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
- rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
- rfd->tail = 0;
+ p->hits=0;
+
+ p->rfd_l = rset_open (info->rset_l, RSETF_READ);
+ p->rfd_r = rset_open (info->rset_r, RSETF_READ);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->tail = 0;
return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
- struct rset_bool_rfd **rfdp;
-
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- struct rset_bool_rfd *rfd_tmp = *rfdp;
-
- rset_close (info->rset_l, (*rfdp)->rfd_l);
- rset_close (info->rset_r, (*rfdp)->rfd_r);
- *rfdp = (*rfdp)->next;
-
- rfd_tmp->next = info->free_list;
- info->free_list = rfd_tmp;
+ /* struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv); */
+ struct rset_bool_rfd *prfd=(struct rset_bool_rfd *)rfd->priv;
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ rset_close (prfd->rfd_l);
+ rset_close (prfd->rfd_r);
+ rfd_delete_base(rfd);
}
static void r_rewind (RSFD rfd)
{
- struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
+ /* struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv); */
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
logf (LOG_DEBUG, "rsbool_rewind");
- rset_rewind (info->rset_l, p->rfd_l);
- rset_rewind (info->rset_r, p->rfd_r);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ rset_rewind (p->rfd_l);
+ rset_rewind (p->rfd_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
p->hits=0;
}
-static int r_forward (RSET ct, RSFD rfd, void *buf,
+static int r_forward (RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
- struct rset_bool_info *info = ((struct rset_bool_rfd*)rfd)->info;
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
+ struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
int rc;
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rsbool_forward (L) [%p] '%s' (ct=%p rfd=%p m=%d,%d)",
- rfd, ct->control->desc, ct, rfd, p->more_l, p->more_r);
-#endif
if ( p->more_l && ((cmpfunc)(untilbuf,p->buf_l)==2) )
- p->more_l = rset_forward(info->rset_l, p->rfd_l, p->buf_l,
+ p->more_l = rset_forward(p->rfd_l, p->buf_l,
info->cmp, untilbuf);
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rsbool_forward (R) [%p] '%s' (ct=%p rfd=%p m=%d,%d)",
- rfd, ct->control->desc, ct, rfd, p->more_l, p->more_r);
-#endif
if ( p->more_r && ((cmpfunc)(untilbuf,p->buf_r)==2))
- p->more_r = rset_forward(info->rset_r, p->rfd_r, p->buf_r,
+ p->more_r = rset_forward(p->rfd_r, p->buf_r,
info->cmp, untilbuf);
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rsbool_forward [%p] calling read, m=%d,%d t=%d",
- rfd, p->more_l, p->more_r, p->tail);
-#endif
-
p->tail=0;
- rc = rset_read(ct,rfd,buf);
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rsbool_forward returning [%p] %d m=%d,%d",
- rfd, rc, p->more_l, p->more_r);
-#endif
+ rc = rset_read(rfd,buf);
return rc;
}
static int r_read_and (RSFD rfd, void *buf)
{
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
- struct rset_bool_info *info = p->info;
+ struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
while (p->more_l || p->more_r)
{
if (!cmp)
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
p->tail = 1;
}
else if (cmp == 1)
{
memcpy (buf, p->buf_r, info->key_size);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R m=%d/%d c=%d",
else if (cmp == -1)
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning L m=%d/%d c=%d",
#if OLDCODE
memcpy (buf, p->buf_r, info->key_size);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
if (p->tail)
{
if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
if (p->tail)
{
memcpy (buf, p->buf_r, info->key_size);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_r = rset_forward( info->rset_r, p->rfd_r,
+ p->more_r = rset_forward( p->rfd_r,
p->buf_r, (info->cmp), p->buf_l);
else
return 0; /* no point in reading further */
{
#if OLDCODE
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
if (p->tail)
{
if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
if (p->tail)
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_l = rset_forward(
- info->rset_l, p->rfd_l,
+ p->more_l = rset_forward(p->rfd_l,
p->buf_l, (info->cmp), p->buf_r);
else
return 0; /* no point in reading further */
static int r_read_or (RSFD rfd, void *buf)
{
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
- struct rset_bool_info *info = p->info;
+ struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
while (p->more_l || p->more_r)
{
if (!cmp)
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning A m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
else if (cmp > 0)
{
memcpy (buf, p->buf_r, info->key_size);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning B m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
else
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read ( p->rfd_l, p->buf_l);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning C m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
static int r_read_not (RSFD rfd, void *buf)
{
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
- struct rset_bool_info *info = p->info;
+ struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv);
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
while (p->more_l || p->more_r)
{
if (cmp < -1)
{
memcpy (buf, p->buf_l, info->key_size);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
p->hits++;
return 1;
}
else if (cmp > 1)
{
- p->more_r = rset_forward(
- info->rset_r, p->rfd_r,
+ p->more_r = rset_forward( p->rfd_r,
p->buf_r, (info->cmp), p->buf_l);
}
else
memcpy (buf, p->buf_l, info->key_size);
do
{
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l);
if (!p->more_l)
break;
cmp = (*info->cmp)(p->buf_l, buf);
} while (cmp >= -1 && cmp <= 1);
do
{
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r);
if (!p->more_r)
break;
cmp = (*info->cmp)(p->buf_r, buf);
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
- struct rset_bool_info *info = p->info;
+ struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
double lcur,ltot;
double rcur,rtot;
double r;
ltot=-1; rtot=-1;
- rset_pos(info->rset_l, p->rfd_l, &lcur, <ot);
- rset_pos(info->rset_r, p->rfd_r, &rcur, &rtot);
+ rset_pos(p->rfd_l, &lcur, <ot);
+ rset_pos(p->rfd_r, &rcur, &rtot);
if ( (rtot<0) && (ltot<0)) { /*no position */
*current=rcur; /* return same as you got */
*total=rtot; /* probably -1 for not available */
-/* $Id: rset.c,v 1.28 2004-08-24 15:00:16 heikki Exp $
+/* $Id: rset.c,v 1.29 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <yaz/nmem.h>
#include <rset.h>
+
+/* creates an rfd. Either allocates a new one, in which case the priv */
+/* pointer is null, and will have to be filled in, or picks up one */
+/* from the freelist, in which case the priv is already allocated, */
+/* and presumably everything that hangs from it as well */
+
+RSFD rfd_create_base(RSET rs)
+{
+ RSFD rnew=rs->free_list;
+ if (rnew) {
+ rs->free_list=rnew->next;
+ assert(rnew->rset==rs);
+ /* logf(LOG_DEBUG,"rfd-create_base (fl): rfd=%p rs=%p fl=%p priv=%p",
+ rnew, rs, rs->free_list, rnew->priv); */
+ } else {
+ rnew=nmem_malloc(rs->nmem, sizeof(*rnew));
+ rnew->priv=NULL;
+ rnew->rset=rs;
+ /* logf(LOG_DEBUG,"rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p",
+ rnew, rs, rs->free_list, rnew->priv); */
+ }
+ rnew->next=NULL; /* not part of any (free?) list */
+ return rnew;
+}
+
+/* puts an rfd into the freelist of the rset. Only when the rset gets */
+/* deleted, will all the nmem disappear */
+void rfd_delete_base(RSFD rfd)
+{
+ RSET rs=rfd->rset;
+ /* logf(LOG_DEBUG,"rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p",
+ rfd, rs, rfd->priv, rs->free_list); */
+ assert(NULL == rfd->next);
+ rfd->next=rs->free_list;
+ rs->free_list=rfd;
+}
+
RSET rset_create_base(const struct rset_control *sel, NMEM nmem)
/* FIXME - Add keysize and cmp function */
/* FIXME - Add a general key-func block for cmp, dump, etc */
{
RSET rnew;
NMEM M;
- logf (LOG_DEBUG, "rs_create(%s)", sel->desc);
if (nmem)
M=nmem;
else
M=nmem_create();
rnew = (RSET) nmem_malloc(M,sizeof(*rnew));
+ /* logf (LOG_DEBUG, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rnew, nmem); */
rnew->nmem=M;
if (nmem)
rnew->my_nmem=0;
rnew->control = sel;
rnew->count = 1;
rnew->priv = 0;
+ rnew->free_list=NULL;
return rnew;
}
void rset_delete (RSET rs)
{
(rs->count)--;
+/* logf(LOG_DEBUG,"rs_delete(%s), rs=%p, count=%d",
+ rs->control->desc, rs, rs->count); */
if (!rs->count)
{
(*rs->control->f_delete)(rs);
return rs;
}
+#if 0
void rset_default_pos (RSFD rfd, double *current, double *total)
{ /* This should never really be needed, but it is still used in */
/* those rsets that we don't really plan to use, like isam-s */
*current=-1; /* signal that pos is not implemented */
*total=-1;
} /* rset_default_pos */
+#endif
-int rset_default_forward(RSET ct, RSFD rfd, void *buf,
+int rset_default_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
int more=1;
int cmp=2;
logf (LOG_DEBUG, "rset_default_forward starting '%s' (ct=%p rfd=%p)",
- ct->control->desc, ct,rfd);
+ rfd->rset->control->desc, rfd->rset, rfd);
/* key_logdump(LOG_DEBUG, untilbuf); */
while ( (cmp==2) && (more))
{
logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
- more=rset_read(ct, rfd, buf);
+ more=rset_read(rfd, buf);
if (more)
cmp=(*cmpfunc)(untilbuf,buf);
/* if (more)
-/* $Id: rsisamb.c,v 1.18 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsisamb.c,v 1.19 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
static const struct rset_control control =
{
"isamb",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward, /* rset_default_forward, */
r_pos,
struct rset_pp_info {
ISAMB_PP pt;
- struct rset_pp_info *next;
- struct rset_isamb_info *info;
void *buf;
};
ISAMB_P pos;
int key_size;
int (*cmp)(const void *p1, const void *p2);
- struct rset_pp_info *ispt_list;
- struct rset_pp_info *free_list;
};
RSET rsisamb_create( NMEM nmem, int key_size,
info->cmp = cmp;
info->is=is;
info->pos=pos;
- info->ispt_list = NULL;
- info->free_list = NULL;
rnew->priv=info;
return rnew;
}
static void r_delete (RSET ct)
{
- struct rset_isamb_info *info = (struct rset_isamb_info *) ct->priv;
-
logf (LOG_DEBUG, "rsisamb_delete");
- assert (info->ispt_list == NULL);
-}
-
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_isamb_parms *pt = (rset_isamb_parms *) parms;
- struct rset_isamb_info *info;
-
- info = (struct rset_isamb_info *) xmalloc (sizeof(*info));
- info->is = pt->is;
- info->pos = pt->pos;
- info->key_size = pt->key_size;
- info->cmp = pt->cmp;
- info->ispt_list = NULL;
- return info;
}
-#endif
RSFD r_open (RSET ct, int flag)
{
struct rset_isamb_info *info = (struct rset_isamb_info *) ct->priv;
+ RSFD rfd;
struct rset_pp_info *ptinfo;
- logf (LOG_DEBUG, "risamb_open");
if (flag & RSETF_WRITE)
{
logf (LOG_FATAL, "ISAMB set type is read-only");
return NULL;
}
- ptinfo = info->free_list;
- if (ptinfo)
- info->free_list=ptinfo->next;
+ rfd=rfd_create_base(ct);
+ if (rfd->priv)
+ ptinfo=(struct rset_pp_info *) (rfd->priv);
else {
ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
+ rfd->priv=ptinfo;
}
- ptinfo->next = info->ispt_list;
- info->ispt_list = ptinfo;
ptinfo->pt = isamb_pp_open (info->is, info->pos);
- ptinfo->info = info;
- return ptinfo;
+ return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_isamb_info *info = ((struct rset_pp_info*) rfd)->info;
- struct rset_pp_info **ptinfop;
-
- for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
- if (*ptinfop == rfd)
- {
- struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
- isamb_pp_close ((*ptinfop)->pt);
- *ptinfop = (*ptinfop)->next;
- tmp->next=info->free_list;
- info->free_list=tmp;
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+ isamb_pp_close (ptinfo->pt);
+ rfd_delete_base(rfd);
}
abort ();
}
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
- int i;
- struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rset_rsisamb_forward starting '%s' (ct=%p rfd=%p)",
- ct->control->desc, ct,rfd);
- key_logdump(LOG_DEBUG, untilbuf);
- key_logdump(LOG_DEBUG, buf);
-#endif
-
- i=isamb_pp_forward(pinfo->pt, buf, untilbuf);
-#if RSET_DEBUG
- logf (LOG_DEBUG, "rset_rsisamb_forward returning %d",i);
-#endif
- return i;
+ struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
+ return isamb_pp_forward(pinfo->pt, buf, untilbuf);
}
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
+ struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
assert(rfd);
isamb_pp_pos(pinfo->pt, current, total);
#if RSET_DEBUG
static int r_read (RSFD rfd, void *buf)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
- int r;
+ struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
- r = isamb_pp_read(pinfo->pt, buf);
- return r;
+ return isamb_pp_read(pinfo->pt, buf);
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rsisamc.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsisamc.c,v 1.23 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_rewind (RSFD rfd);
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
+static void r_pos (RSFD rfd, double *current, double *total);
static const struct rset_control control =
{
"isamc",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
rset_default_forward,
- rset_default_pos,
+ r_pos,
r_read,
r_write,
};
assert (info->ispt_list == NULL);
}
-/*
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_isamc_parms *pt = (rset_isamc_parms *) parms;
- struct rset_isamc_info *info;
-
- info = (struct rset_isamc_info *) xmalloc (sizeof(*info));
- info->is = pt->is;
- info->pos = pt->pos;
- info->key_size = pt->key_size;
- info->cmp = pt->cmp;
- info->ispt_list = NULL;
- return info;
-}
-*/
RSFD r_open (RSET ct, int flag)
{
struct rset_isamc_info *info = (struct rset_isamc_info *) ct->priv;
+ RSFD rfd;
struct rset_pp_info *ptinfo;
logf (LOG_DEBUG, "risamc_open");
logf (LOG_FATAL, "ISAMC set type is read-only");
return NULL;
}
- ptinfo = info->free_list;
- if (ptinfo)
- info->free_list=ptinfo->next;
+ rfd = rfd_create_base(ct);
+ if (rfd->priv)
+ ptinfo=(struct rset_pp_info *)rfd->priv;
else {
ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
+ rfd->priv=ptinfo;
ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
}
- ptinfo->next = info->ispt_list;
- info->ispt_list = ptinfo;
- ptinfo->pt = isc_pp_open (info->is, info->pos);
- ptinfo->info = info;
- return ptinfo;
+ return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_isamc_info *info = ((struct rset_pp_info*) rfd)->info;
- struct rset_pp_info **ptinfop;
-
- for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
- if (*ptinfop == rfd)
- {
- struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
- isc_pp_close ((*ptinfop)->pt);
- *ptinfop = (*ptinfop)->next;
- tmp->next=info->free_list;
- info->free_list=tmp;
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ struct rset_pp_info *p=(struct rset_pp_info *)(rfd->priv);
+
+ isc_pp_close (p->pt);
+ rfd_delete_base(rfd);
}
static int r_read (RSFD rfd, void *buf)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
+ struct rset_pp_info *p=(struct rset_pp_info *)(rfd->priv);
int r;
- r = isc_pp_read(pinfo->pt, buf);
+ r = isc_pp_read(p->pt, buf);
return r;
}
logf (LOG_FATAL, "ISAMC set type is read-only");
return -1;
}
+
+static void r_pos (RSFD rfd, double *current, double *total)
+{
+ *current=-1; /* sorry, not implemented yet */
+ *total=-1;
+}
-/* $Id: rsisams.c,v 1.10 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsisams.c,v 1.11 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_rewind (RSFD rfd);
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
+static void r_pos (RSFD rfd, double *current, double *total);
static const struct rset_control control =
{
"isams",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
rset_default_forward,
- rset_default_pos,
+ r_pos,
r_read,
r_write,
};
struct rset_pp_info {
ISAMS_PP pt;
- struct rset_pp_info *next;
- struct rset_isams_info *info;
};
struct rset_isams_info {
ISAMS is;
ISAMS_P pos;
- struct rset_pp_info *ispt_list;
};
assert(cmp);
info->is=is;
info->pos=pos;
- info->ispt_list = NULL;
rnew->priv=info;
return rnew;
}
static void r_delete (RSET ct)
{
- struct rset_isams_info *info = (struct rset_isams_info *) ct->priv;
-
logf (LOG_DEBUG, "rsisams_delete");
- assert (info->ispt_list == NULL);
- /* xfree (info); */
+ rset_delete(ct);
}
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_isams_parms *pt = (struct rset_isams_parms *) parms;
- struct rset_isams_info *info;
-
- info = (struct rset_isams_info *) xmalloc (sizeof(*info));
- info->is = pt->is;
- info->pos = pt->pos;
- info->ispt_list = NULL;
- return info;
-}
-#endif
RSFD r_open (RSET ct, int flag)
{
struct rset_isams_info *info = (struct rset_isams_info *) ct->priv;
+ RSFD rfd;
struct rset_pp_info *ptinfo;
logf (LOG_DEBUG, "risams_open");
logf (LOG_FATAL, "ISAMS set type is read-only");
return NULL;
}
- ptinfo = (struct rset_pp_info *) xmalloc (sizeof(*ptinfo));
- ptinfo->next = info->ispt_list;
- info->ispt_list = ptinfo;
- ptinfo->pt = isams_pp_open (info->is, info->pos);
- ptinfo->info = info;
- return ptinfo;
+ rfd=rfd_create_base(ct);
+ if (rfd->priv)
+ ptinfo=(struct rset_pp_info *)(rfd->priv);
+ else {
+ ptinfo = (struct rset_pp_info *) nmem_malloc(ct->nmem,sizeof(*ptinfo));
+ ptinfo->pt = isams_pp_open (info->is, info->pos);
+ rfd->priv=ptinfo;
+ }
+ return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_isams_info *info = ((struct rset_pp_info*) rfd)->info;
- struct rset_pp_info **ptinfop;
-
- for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
- if (*ptinfop == rfd)
- {
- isams_pp_close ((*ptinfop)->pt);
- *ptinfop = (*ptinfop)->next;
- xfree (rfd);
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+
+ isams_pp_close (ptinfo->pt);
+ rfd_delete_base(rfd);
}
static void r_rewind (RSFD rfd)
static int r_read (RSFD rfd, void *buf)
{
- return isams_pp_read( ((struct rset_pp_info*) rfd)->pt, buf);
+ struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+ return isams_pp_read(ptinfo->pt, buf);
}
static int r_write (RSFD rfd, const void *buf)
logf (LOG_FATAL, "ISAMS set type is read-only");
return -1;
}
+
+static void r_pos (RSFD rfd, double *current, double *total)
+{
+ *current=-1; /* sorry, not implemented yet */
+ *total=-1;
+}
+++ /dev/null
-/* $Id: rsm_or.c,v 1.20 2004-08-20 14:44:46 heikki Exp $
- Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
- Index Data Aps
-
-This file is part of the Zebra server.
-
-Zebra is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
-
-Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with Zebra; see the file LICENSE.zebra. If not, write to the
-Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.
-*/
-
-
-
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <zebrautl.h>
-#include <isamc.h>
-#include <rsm_or.h>
-
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms);
-static RSFD r_open (RSET ct, int flag);
-static void r_close (RSFD rfd);
-static void r_delete (RSET ct);
-static void r_rewind (RSFD rfd);
-static int r_read (RSFD rfd, void *buf);
-static int r_write (RSFD rfd, const void *buf);
-
-static const struct rset_control control =
-{
- "m-or (old)",
- r_create,
- r_open,
- r_close,
- r_delete,
- r_rewind,
- rset_default_forward, /* FIXME */
- rset_default_pos, /* FIXME */
- r_read,
- r_write,
-};
-
-const struct rset_control *rset_kind_m_or = &control;
-
-struct rset_mor_info {
- int key_size;
- int no_rec;
- int (*cmp)(const void *p1, const void *p2);
- ISAMC isc;
- ISAMC_P *isam_positions;
-
- int no_isam_positions;
- int no_save_positions;
- struct rset_mor_rfd *rfd_list;
-};
-
-struct trunc_info {
- int *ptr;
- int *indx;
- char **heap;
- int heapnum;
- int (*cmp)(const void *p1, const void *p2);
- int keysize;
- char *swapbuf;
- char *tmpbuf;
- char *buf;
-};
-
-struct rset_mor_rfd {
- int flag;
- int position;
- int position_max;
- ISAMC_PP *ispt;
- struct rset_mor_rfd *next;
- struct rset_mor_info *info;
- struct trunc_info *ti;
- char *pbuf;
-};
-
-static void heap_swap (struct trunc_info *ti, int i1, int i2)
-{
- int swap;
-
- swap = ti->ptr[i1];
- ti->ptr[i1] = ti->ptr[i2];
- ti->ptr[i2] = swap;
-}
-
-static void heap_delete (struct trunc_info *ti)
-{
- int cur = 1, child = 2;
-
- heap_swap (ti, 1, ti->heapnum--);
- while (child <= ti->heapnum) {
- if (child < ti->heapnum &&
- (*ti->cmp)(ti->heap[ti->ptr[child]],
- ti->heap[ti->ptr[1+child]]) > 0)
- child++;
- if ((*ti->cmp)(ti->heap[ti->ptr[cur]],
- ti->heap[ti->ptr[child]]) > 0)
- {
- heap_swap (ti, cur, child);
- cur = child;
- child = 2*cur;
- }
- else
- break;
- }
-}
-
-static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
-{
- int cur, parent;
-
- cur = ++(ti->heapnum);
- memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize);
- ti->indx[ti->ptr[cur]] = indx;
- parent = cur/2;
- while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]],
- ti->heap[ti->ptr[cur]]) > 0)
- {
- heap_swap (ti, cur, parent);
- cur = parent;
- parent = cur/2;
- }
-}
-
-static
-struct trunc_info *heap_init (int size, int key_size,
- int (*cmp)(const void *p1, const void *p2))
-{
- struct trunc_info *ti = (struct trunc_info *) xmalloc (sizeof(*ti));
- int i;
-
- ++size;
- ti->heapnum = 0;
- ti->keysize = key_size;
- ti->cmp = cmp;
- ti->indx = (int *) xmalloc (size * sizeof(*ti->indx));
- ti->heap = (char **) xmalloc (size * sizeof(*ti->heap));
- ti->ptr = (int *) xmalloc (size * sizeof(*ti->ptr));
- ti->swapbuf = (char *) xmalloc (ti->keysize);
- ti->tmpbuf = (char *) xmalloc (ti->keysize);
- ti->buf = (char *) xmalloc (size * ti->keysize);
- for (i = size; --i >= 0; )
- {
- ti->ptr[i] = i;
- ti->heap[i] = ti->buf + ti->keysize * i;
- }
- return ti;
-}
-
-static void heap_close (struct trunc_info *ti)
-{
- xfree (ti->buf);
- xfree (ti->ptr);
- xfree (ti->indx);
- xfree (ti->heap);
- xfree (ti->swapbuf);
- xfree (ti->tmpbuf);
- xfree (ti);
-}
-
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_m_or_parms *r_parms = (rset_m_or_parms *) parms;
- struct rset_mor_info *info;
-
- ct->flags |= RSET_FLAG_VOLATILE;
- info = (struct rset_mor_info *) xmalloc (sizeof(*info));
- info->key_size = r_parms->key_size;
- assert (info->key_size > 1);
- info->cmp = r_parms->cmp;
-
- info->no_save_positions = r_parms->no_save_positions;
-
- info->isc = r_parms->isc;
- info->no_isam_positions = r_parms->no_isam_positions;
- info->isam_positions = (ISAMC_P *)
- xmalloc (sizeof(*info->isam_positions) * info->no_isam_positions);
- memcpy (info->isam_positions, r_parms->isam_positions,
- sizeof(*info->isam_positions) * info->no_isam_positions);
- info->rfd_list = NULL;
-
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = r_parms->rset_term;
- return info;
-}
-
-static RSFD r_open (RSET ct, int flag)
-{
- struct rset_mor_rfd *rfd;
- struct rset_mor_info *info = (struct rset_mor_info *) ct->buf;
- int i;
-
- if (flag & RSETF_WRITE)
- {
- logf (LOG_FATAL, "m_or set type is read-only");
- return NULL;
- }
- rfd = (struct rset_mor_rfd *) xmalloc (sizeof(*rfd));
- rfd->flag = flag;
- rfd->next = info->rfd_list;
- rfd->info = info;
- info->rfd_list = rfd;
-
- rfd->ispt = (ISAMC_PP *)
- xmalloc (sizeof(*rfd->ispt) * info->no_isam_positions);
-
- rfd->ti = heap_init (info->no_isam_positions, info->key_size, info->cmp);
-
- ct->rset_terms[0]->nn = 0;
- for (i = 0; i<info->no_isam_positions; i++)
- {
- rfd->ispt[i] = isc_pp_open (info->isc, info->isam_positions[i]);
-
- ct->rset_terms[0]->nn += isc_pp_num (rfd->ispt[i]);
-
- if (isc_pp_read (rfd->ispt[i], rfd->ti->tmpbuf))
- heap_insert (rfd->ti, rfd->ti->tmpbuf, i);
- else
- {
- isc_pp_close (rfd->ispt[i]);
- rfd->ispt[i] = NULL;
- }
- }
- rfd->position = info->no_save_positions;
- rfd->pbuf = 0;
- r_rewind (rfd);
- return rfd;
-}
-
-static void r_close (RSFD rfd)
-{
- struct rset_mor_info *info = ((struct rset_mor_rfd*)rfd)->info;
- struct rset_mor_rfd **rfdp;
- int i;
-
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- *rfdp = (*rfdp)->next;
-
- heap_close (((struct rset_mor_rfd *) rfd)->ti);
- for (i = 0; i<info->no_isam_positions; i++)
- if (((struct rset_mor_rfd *) rfd)->ispt[i])
- isc_pp_close (((struct rset_mor_rfd *) rfd)->ispt[i]);
- xfree (((struct rset_mor_rfd *)rfd)->ispt);
- xfree (((struct rset_mor_rfd *)rfd)->pbuf);
- xfree (rfd);
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
-}
-
-static void r_delete (RSET ct)
-{
- struct rset_mor_info *info = (struct rset_mor_info *) ct->buf;
- assert (info->rfd_list == NULL);
- xfree (info->isam_positions);
- xfree (info);
-}
-
-static void r_rewind (RSFD rfd)
-{
-}
-
-
-static int r_read (RSFD rfd, void *buf)
-{
- struct rset_mor_rfd *mrfd = (struct rset_mor_rfd *) rfd;
- struct trunc_info *ti = mrfd->ti;
- int n = ti->indx[ti->ptr[1]];
-
- if (!ti->heapnum)
- return 0;
- memcpy (buf, ti->heap[ti->ptr[1]], ti->keysize);
- if (((struct rset_mor_rfd *) rfd)->position)
- {
- if (isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf))
- {
- heap_delete (ti);
- if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
- ((struct rset_mor_rfd *) rfd)->position--;
- heap_insert (ti, ti->tmpbuf, n);
- }
- else
- heap_delete (ti);
- rfd->pbuf = xmalloc (info->key_size);
- if (mrfd->countp && (
- *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1))
- {
- memcpy (mrfd->pbuf, buf, ti->keysize);
- (*mrfd->countp)++;
- }
- return 1;
- }
- while (1)
- {
- if (!isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf))
- {
- heap_delete (ti);
- break;
- }
- if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
- {
- heap_delete (ti);
- heap_insert (ti, ti->tmpbuf, n);
- break;
- }
- }
- if (mrfd->countp && (
- *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1))
- {
- memcpy (mrfd->pbuf, buf, ti->keysize);
- (*mrfd->countp)++;
- }
- return 1;
-}
-
-static int r_write (RSFD rfd, const void *buf)
-{
- logf (LOG_FATAL, "mor set type is read-only");
- return -1;
-}
-/* $Id: rsmultior.c,v 1.7 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsmultior.c,v 1.8 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_rewind (RSFD rfd);
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
static const struct rset_control control =
{
"multi-or",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward,
r_pos,
int (*cmp)(const void *p1, const void *p2);
int no_rsets;
RSET *rsets;
- struct rset_multior_rfd *rfd_list; /* rfds in use */
- struct rset_multior_rfd *free_list; /* rfds free */
- /* rfds are allocated when first opened, if nothing in freelist */
- /* when allocated, all their pointers are allocated as well, and */
- /* those are kept intact when in the freelist, ready to be reused */
};
int flag;
struct heap_item *items; /* we alloc and free them here */
HEAP h;
- struct rset_multior_rfd *next;
- struct rset_multior_info *info;
zint hits; /* returned so far */
char *prevvalue; /* to see if we are in another record */
/* FIXME - is this really needed? */
info->no_rsets=no_rsets;
info->rsets=(RSET*)nmem_malloc(rnew->nmem, no_rsets*sizeof(*rsets));
memcpy(info->rsets,rsets,no_rsets*sizeof(*rsets));
- info->rfd_list = NULL;
- info->free_list = NULL;
rnew->priv=info;
return rnew;
}
{
struct rset_multior_info *info = (struct rset_multior_info *) ct->priv;
int i;
-
- assert (info->rfd_list == NULL);
for(i=0;i<info->no_rsets;i++)
rset_delete(info->rsets[i]);
}
-#if 0
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_multior_parms *r_parms = (rset_multior_parms *) parms;
- struct rset_multior_info *info;
- info = (struct rset_multior_info *) xmalloc (sizeof(*info));
- info->key_size = r_parms->key_size;
- assert (info->key_size > 1);
- info->cmp = r_parms->cmp;
- info->no_rsets= r_parms->no_rsets;
- info->rsets=r_parms->rsets; /* now we own it! */
- info->rfd_list=0;
- return info;
-}
-#endif
static RSFD r_open (RSET ct, int flag)
{
- struct rset_multior_rfd *rfd;
+ RSFD rfd;
+ struct rset_multior_rfd *p;
struct rset_multior_info *info = (struct rset_multior_info *) ct->priv;
int i;
logf (LOG_FATAL, "multior set type is read-only");
return NULL;
}
- rfd=info->free_list;
- if (rfd) {
- info->free_list=rfd->next;
- heap_clear(rfd->h);
- assert(rfd->items);
+ rfd=rfd_create_base(ct);
+ if (rfd->priv) {
+ p=(struct rset_multior_rfd *)rfd->priv;
+ heap_clear(p->h);
+ assert(p->items);
/* all other pointers shouls already be allocated, in right sizes! */
}
else {
- rfd = (struct rset_multior_rfd *) nmem_malloc (ct->nmem,sizeof(*rfd));
- rfd->h = heap_create( ct->nmem, info->no_rsets,
+ p = (struct rset_multior_rfd *) nmem_malloc (ct->nmem,sizeof(*p));
+ rfd->priv=p;
+ p->h = heap_create( ct->nmem, info->no_rsets,
info->key_size, info->cmp);
- rfd->items=(struct heap_item *) nmem_malloc(ct->nmem,
- info->no_rsets*sizeof(*rfd->items));
+ p->items=(struct heap_item *) nmem_malloc(ct->nmem,
+ info->no_rsets*sizeof(*p->items));
for (i=0; i<info->no_rsets; i++){
- rfd->items[i].rset=info->rsets[i];
- rfd->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
+ p->items[i].rset=info->rsets[i];
+ p->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
}
}
- rfd->flag = flag;
- rfd->next = info->rfd_list;
- rfd->info = info;
- info->rfd_list = rfd;
- rfd->prevvalue=0;
- rfd->hits=0;
+ p->flag = flag;
+ p->prevvalue=0;
+ p->hits=0;
for (i=0; i<info->no_rsets; i++){
- rfd->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
- if ( rset_read(rfd->items[i].rset, rfd->items[i].fd,
- rfd->items[i].buf) )
- heap_insert(rfd->h, &(rfd->items[i]));
+ p->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
+ if ( rset_read(p->items[i].fd, p->items[i].buf) )
+ heap_insert(p->h, &(p->items[i]));
}
return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
- struct rset_multior_info *info = mrfd->info;
- struct rset_multior_rfd **rfdp;
+ struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+ struct rset_multior_rfd *p=(struct rset_multior_rfd *)(rfd->priv);
int i;
-
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- *rfdp = (*rfdp)->next;
-
- heap_destroy (mrfd->h);
- for (i = 0; i<info->no_rsets; i++) {
- if (mrfd->items[i].fd)
- rset_close(info->rsets[i],mrfd->items[i].fd);
- }
- mrfd->next=info->free_list;
- info->free_list=mrfd;
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+
+ heap_destroy (p->h);
+ for (i = 0; i<info->no_rsets; i++)
+ if (p->items[i].fd)
+ rset_close(p->items[i].fd);
+ rfd_delete_base(rfd);
}
}
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
- struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
- struct rset_multior_info *info = mrfd->info;
+ struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+ struct rset_multior_rfd *mrfd=(struct rset_multior_rfd *)(rfd->priv);
struct heap_item it;
int rdres;
if (heap_empty(mrfd->h))
return 0;
if (cmpfunc)
- assert(cmpfunc==mrfd->info->cmp);
+ assert(cmpfunc==info->cmp);
it = *(mrfd->h->heap[1]);
memcpy(buf,it.buf, info->key_size);
(mrfd->hits)++;
if (untilbuf)
- rdres=rset_forward(it.rset, it.fd, it.buf, cmpfunc,untilbuf);
+ rdres=rset_forward(it.fd, it.buf, cmpfunc,untilbuf);
else
- rdres=rset_read(it.rset, it.fd, it.buf);
+ rdres=rset_read(it.fd, it.buf);
if ( rdres )
heap_balance(mrfd->h);
else
static int r_read (RSFD rfd, void *buf)
{
- return r_forward(0,rfd, buf,0,0);
+ return r_forward(rfd, buf,0,0);
}
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_multior_rfd *mrfd = (struct rset_multior_rfd *) rfd;
- struct rset_multior_info *info = mrfd->info;
+ struct rset_multior_info *info=(struct rset_multior_info *)(rfd->rset->priv);
+ struct rset_multior_rfd *mrfd=(struct rset_multior_rfd *)(rfd->priv);
double cur, tot;
double scur=0.0, stot=0.0;
int i;
for (i=0; i<info->no_rsets; i++){
- rset_pos(mrfd->items[i].rset, mrfd->items[i].fd, &cur, &tot);
+ rset_pos(mrfd->items[i].fd, &cur, &tot);
logf(LOG_LOG, "r_pos: %d %0.1f %0.1f", i, cur,tot);
scur += cur;
stot += tot;
-/* $Id: rsnull.c,v 1.23 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsnull.c,v 1.24 2004-08-31 10:43:39 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#include <zebrautl.h>
#include <rsnull.h>
-/* FIXME - Use the nmem instead of xmalloc all the way through */
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static const struct rset_control control =
{
"null",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
rset_default_forward,
r_pos,
return rnew;
}
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
- return NULL;
-}
-#endif
-
static RSFD r_open (RSET ct, int flag)
{
+ RSFD rfd;
if (flag & RSETF_WRITE)
{
logf (LOG_FATAL, "NULL set type is read-only");
return NULL;
}
- return "";
+ rfd=rfd_create_base(ct);
+ rfd->priv=NULL;
+ return rfd;
}
static void r_close (RSFD rfd)
{
+ rfd_delete_base(rfd);
}
static void r_delete (RSET ct)
-/* $Id: rsprox.c,v 1.12 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rsprox.c,v 1.13 2004-08-31 10:43:40 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf,
+static int r_forward(RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static int r_read (RSFD rfd, void *buf);
static const struct rset_control control =
{
"prox",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
r_forward,
r_pos,
int key_size;
int (*cmp)(const void *p1, const void *p2);
int (*getseq)(const void *p);
- struct rset_prox_rfd *rfd_list;
- struct rset_prox_rfd *free_list;
};
struct rset_prox_rfd {
RSFD *rfd;
char **buf; /* lookahead key buffers */
char *more; /* more in each lookahead? */
- struct rset_prox_rfd *next;
- struct rset_prox_info *info;
zint hits;
};
info->exclusion=exclusion;
info->relation=relation;
info->distance=distance;
- info->rfd_list = NULL;
- info->free_list = NULL;
rnew->priv=info;
return rnew;
}
struct rset_prox_info *info = (struct rset_prox_info *) ct->priv;
int i;
- assert (info->rfd_list == NULL);
for (i = 0; i<info->rset_no; i++)
rset_delete (info->rset[i]);
}
static RSFD r_open (RSET ct, int flag)
{
struct rset_prox_info *info = (struct rset_prox_info *) ct->priv;
- struct rset_prox_rfd *rfd;
+ RSFD rfd;
+ struct rset_prox_rfd *p;
int i;
if (flag & RSETF_WRITE)
logf (LOG_FATAL, "prox set type is read-only");
return NULL;
}
- rfd = info->free_list;
- if (rfd)
- info->free_list=rfd->next;
+ rfd = rfd_create_base(ct);
+ if (rfd->priv)
+ p=(struct rset_prox_rfd *)(rfd->priv);
else {
- rfd = (struct rset_prox_rfd *) xmalloc (sizeof(*rfd));
- rfd->more = nmem_malloc (ct->nmem,sizeof(*rfd->more) * info->rset_no);
- rfd->buf = nmem_malloc(ct->nmem,sizeof(*rfd->buf) * info->rset_no);
+ p = (struct rset_prox_rfd *) nmem_malloc (ct->nmem,sizeof(*p));
+ rfd->priv=p;
+ p->more = nmem_malloc (ct->nmem,sizeof(*p->more) * info->rset_no);
+ p->buf = nmem_malloc(ct->nmem,sizeof(*p->buf) * info->rset_no);
for (i = 0; i < info->rset_no; i++)
- rfd->buf[i] = nmem_malloc(ct->nmem,info->key_size);
- rfd->rfd = nmem_malloc(ct->nmem,sizeof(*rfd->rfd) * info->rset_no);
+ p->buf[i] = nmem_malloc(ct->nmem,info->key_size);
+ p->rfd = nmem_malloc(ct->nmem,sizeof(*p->rfd) * info->rset_no);
}
logf(LOG_DEBUG,"rsprox (%s) open [%p]", ct->control->desc, rfd);
- rfd->next = info->rfd_list;
- info->rfd_list = rfd;
- rfd->info = info;
-
for (i = 0; i < info->rset_no; i++) {
- rfd->rfd[i] = rset_open (info->rset[i], RSETF_READ);
- rfd->more[i] = rset_read (info->rset[i], rfd->rfd[i],
- rfd->buf[i]);
+ p->rfd[i] = rset_open (info->rset[i], RSETF_READ);
+ p->more[i] = rset_read (p->rfd[i], p->buf[i]);
}
- rfd->hits=0;
+ p->hits=0;
return rfd;
}
static void r_close (RSFD rfd)
{
- struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
- struct rset_prox_rfd **rfdp;
+ struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+ struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- int i;
- struct rset_prox_rfd *rfd_tmp=*rfdp;
- for (i = 0; i<info->rset_no; i++)
- rset_close (info->rset[i], (*rfdp)->rfd[i]);
- *rfdp = (*rfdp)->next;
- rfd_tmp->next=info->free_list;
- info->free_list=rfd_tmp;
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ int i;
+ for (i = 0; i<info->rset_no; i++)
+ rset_close (p->rfd[i]);
+ rfd_delete_base(rfd);
}
static void r_rewind (RSFD rfd)
{
- struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
- struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+ struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+ struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
int i;
logf (LOG_DEBUG, "rsprox_rewind");
for (i = 0; i < info->rset_no; i++)
{
- rset_rewind (info->rset[i], p->rfd[i]);
- p->more[i] = rset_read (info->rset[i], p->rfd[i], p->buf[i]);
+ rset_rewind (p->rfd[i]);
+ p->more[i] = rset_read (p->rfd[i], p->buf[i]);
}
p->hits=0;
}
-static int r_forward (RSET ct, RSFD rfd, void *buf,
+static int r_forward (RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
- /* Note: CT is not used. We _can_ pass NULL for it */
- struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
- struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+ struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+ struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
int cmp=0;
int i;
if (untilbuf)
{
- /* it's enough to forward first one. Other will follow
- automatically */
+ /* it is enough to forward first one. Other will follow. */
if ( p->more[0] && ((cmpfunc)(untilbuf, p->buf[0]) >= 2) )
- p->more[0] = rset_forward(info->rset[0], p->rfd[0],
- p->buf[0], info->cmp,
- untilbuf);
+ p->more[0] = rset_forward(p->rfd[0], p->buf[0],
+ info->cmp, untilbuf);
}
if (info->ordered && info->relation == 3 && info->exclusion == 0
&& info->distance == 1)
{
if (!p->more[i])
{
- p->more[0] = 0; /* saves us a goto out of while loop. */
+ p->more[0] = 0; /* saves us a goto out of while loop. */
break;
}
cmp = (*info->cmp) (p->buf[i], p->buf[i-1]);
if (cmp > 1)
{
- p->more[i-1] = rset_forward (info->rset[i-1],
- p->rfd[i-1],
+ p->more[i-1] = rset_forward (p->rfd[i-1],
p->buf[i-1],
info->cmp,
p->buf[i]);
{
if ((*info->getseq)(p->buf[i-1]) +1 !=
(*info->getseq)(p->buf[i]))
- {
- p->more[i-1] = rset_read ( info->rset[i-1],
- p->rfd[i-1], p->buf[i-1]);
+ { /* FIXME - We need more flexible multilevel stuff */
+ p->more[i-1] = rset_read ( p->rfd[i-1], p->buf[i-1]);
break;
}
}
else
{
- p->more[i] = rset_forward (info->rset[i], p->rfd[i],
- p->buf[i], info->cmp,
- p->buf[i-1]);
+ p->more[i] = rset_forward (p->rfd[i], p->buf[i],
+ info->cmp, p->buf[i-1]);
break;
}
}
- if (i == p->info->rset_no)
+ if (i == info->rset_no)
{
memcpy (buf, p->buf[0], info->key_size);
- p->more[0] = rset_read (info->rset[0], p->rfd[0], p->buf[0]);
+ p->more[0] = rset_read (p->rfd[0], p->buf[0]);
p->hits++;
return 1;
}
{
int cmp = (*info->cmp)(p->buf[0], p->buf[1]);
if (cmp < -1)
- p->more[0] = rset_forward (info->rset[0], p->rfd[0],
+ p->more[0] = rset_forward (p->rfd[0],
p->buf[0], info->cmp, p->buf[0]);
else if (cmp > 1)
- p->more[1] = rset_forward (info->rset[1], p->rfd[1],
+ p->more[1] = rset_forward (p->rfd[1],
p->buf[1], info->cmp, p->buf[1]);
else
{
int n = 0;
seqno[n++] = (*info->getseq)(p->buf[0]);
- while ((p->more[0] = rset_read (info->rset[0], p->rfd[0],
+ while ((p->more[0] = rset_read (p->rfd[0],
p->buf[0])) >= -1 &&
p->more[0] <= -1)
if (n < 500)
{
memcpy (buf, p->buf[1], info->key_size);
- p->more[1] = rset_read (info->rset[1],
- p->rfd[1], p->buf[1]);
+ p->more[1] = rset_read ( p->rfd[1], p->buf[1]);
p->hits++;
return 1;
}
}
- p->more[1] = rset_read (info->rset[1], p->rfd[1],
- p->buf[1]);
+ p->more[1] = rset_read (p->rfd[1], p->buf[1]);
}
}
}
static int r_read (RSFD rfd, void *buf)
{
- { double cur,tot; r_pos(rfd,&cur,&tot); } /*!*/
- return r_forward(0, rfd, buf, 0, 0);
+ return r_forward(rfd, buf, 0, 0);
}
static int r_write (RSFD rfd, const void *buf)
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
- struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
+ struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
+ struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
int i;
double cur,tot=-1;
double scur=0,stot=0;
for (i = 0; i < info->rset_no; i++)
{
- rset_pos(info->rset[i], p->rfd[i], &cur, &tot);
+ rset_pos(p->rfd[i], &cur, &tot);
if (tot>0) {
scur += cur;
stot += tot;
-/* $Id: rstemp.c,v 1.46 2004-08-26 11:11:59 heikki Exp $
+/* $Id: rstemp.c,v 1.47 2004-08-31 10:43:40 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
static const struct rset_control control =
{
"temp",
+ r_delete,
r_open,
r_close,
- r_delete,
r_rewind,
rset_default_forward,
r_pos,
zint hits; /* no of hits */
char *temp_path;
int (*cmp)(const void *p1, const void *p2);
- struct rset_temp_rfd *rfd_list; /* rfds in use */
- struct rset_temp_rfd *free_list; /* fully alloc'd rfds waiting for reuse*/
};
struct rset_temp_rfd {
- struct rset_temp_info *info;
- struct rset_temp_rfd *next;
void *buf;
size_t pos_cur; /* current position in set */
+ /* FIXME - term pos or what ?? */
zint cur; /* number of the current hit */
};
info->dirty = 0;
info->hits = 0;
info->cmp = cmp;
- info->rfd_list = NULL;
- info->free_list = NULL;
if (!temp_path)
info->temp_path = NULL;
static RSFD r_open (RSET ct, int flag)
{
struct rset_temp_info *info = (struct rset_temp_info *) ct->priv;
- struct rset_temp_rfd *rfd;
+ RSFD rfd;
+ struct rset_temp_rfd *prfd;
if (info->fd == -1 && info->fname)
{
exit (1);
}
}
- rfd = info->free_list;
- if (rfd)
- info->free_list=rfd->next;
- else {
- rfd = (struct rset_temp_rfd *) xmalloc (sizeof(*rfd));
- rfd->buf = xmalloc (info->key_size);
+ rfd = rfd_create_base(ct);
+ if (!rfd->priv){
+ prfd= (struct rset_temp_rfd *) nmem_malloc(ct->nmem, sizeof(*prfd));
+ rfd->priv=(void *)prfd;
+ prfd->buf = nmem_malloc (ct->nmem,info->key_size);
}
- rfd->next = info->rfd_list;
- info->rfd_list = rfd;
- rfd->info = info;
r_rewind (rfd);
-
return rfd;
}
*/
static void r_flush (RSFD rfd, int mk)
{
- struct rset_temp_info *info = ((struct rset_temp_rfd*) rfd)->info;
+ /* struct rset_temp_info *info = ((struct rset_temp_rfd*) rfd)->info; */
+ struct rset_temp_info *info = rfd->rset->priv;
if (!info->fname && mk)
{
static void r_close (RSFD rfd)
{
- struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
- struct rset_temp_rfd **rfdp;
-
- for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
- if (*rfdp == rfd)
- {
- struct rset_temp_rfd *rfd_tmp=*rfdp;
- r_flush (*rfdp, 0);
- *rfdp = (*rfdp)->next;
- rfd_tmp->next=info->free_list;
- info->free_list=rfd_tmp;
-
- if (!info->rfd_list && info->fname && info->fd != -1)
- {
- close (info->fd);
- info->fd = -1;
- }
- return;
- }
- logf (LOG_FATAL, "r_close but no rfd match!");
- assert (0);
+ /*struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv; */
+ struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+ r_flush (rfd, 0);
+ if (info->fname && info->fd != -1)
+ {
+ close (info->fd);
+ info->fd = -1;
+ } /* FIXME - Is this right, don't we risk closing the file too early ?*/
+ rfd_delete_base(rfd);
}
*/
static void r_reread (RSFD rfd)
{
- struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
+ struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
+ struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
if (info->fname)
{
size_t count;
int r;
- info->pos_border = ((struct rset_temp_rfd *)rfd)->pos_cur +
+ info->pos_border = mrfd->pos_cur +
info->buf_size;
if (info->pos_border > info->pos_end)
info->pos_border = info->pos_end;
static void r_rewind (RSFD rfd)
{
- struct rset_temp_info *info = ((struct rset_temp_rfd*)rfd)->info;
-
+ struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) (rfd->priv);
+ struct rset_temp_info *info = (struct rset_temp_info *)(rfd->rset->priv);
r_flush (rfd, 0);
- ((struct rset_temp_rfd *)rfd)->pos_cur = 0;
+ mrfd->pos_cur = 0;
info->pos_buf = 0;
r_reread (rfd);
- ((struct rset_temp_rfd *)rfd)->cur=0;
+ mrfd->cur=0;
}
-/*
-static int r_count (RSET ct)
-{
- struct rset_temp_info *info = (struct rset_temp_info *) ct->buf;
-
- return info->pos_end / info->key_size;
-}
-*/
static int r_read (RSFD rfd, void *buf)
{
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
- struct rset_temp_info *info = mrfd->info;
+ struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
+ struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
size_t nc = mrfd->pos_cur + info->key_size;
static int r_write (RSFD rfd, const void *buf)
{
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
- struct rset_temp_info *info = mrfd->info;
+ struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
+ struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
size_t nc = mrfd->pos_cur + info->key_size;
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
+ /* struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd; */
+ struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
+ struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+
*current=(double) mrfd->cur;
- *total=(double) mrfd->info->hits;
+ *total=(double) info->hits;
}
projects / idzebra-moved-to-github.git / commitdiff