index/limit.c

   1 /* $Id: limit.c,v 1.10 2007-01-15 15:10:16 adam Exp $
   2    Copyright (C) 1995-2007
   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 this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 #include <stdio.h>
  24 #include <assert.h>
  25
  26 #include <yaz/xmalloc.h>
  27 #include <yaz/diagbib1.h>
  28 #include "index.h"
  29
  30 #define ZEBRA_LIMIT_DEBUG 0
  31
  32 struct zebra_limit {
  33     int complement_flag;
  34     zint *ids;
  35 };
  36
  37 void zebra_limit_destroy(struct zebra_limit *zl)
  38 {
  39     if (zl)
  40     {
  41         xfree(zl->ids);
  42         xfree(zl);
  43     }
  44 }
  45
  46 struct zebra_limit *zebra_limit_create(int complement_flag, zint *ids)
  47 {
  48     struct zebra_limit *zl = 0;
  49     size_t i;
  50     if (ids)
  51     {
  52         for (i = 0; ids[i]; i++)
  53             ;
  54         zl = xmalloc(sizeof(*zl));
  55         zl->ids = xmalloc((i+1) * sizeof(*ids));
  56         memcpy(zl->ids, ids, (i+1) * sizeof(*ids));
  57         zl->complement_flag = complement_flag;
  58     }
  59     return zl;
  60 }
  61
  62 static int zebra_limit_filter_cb(const void *buf, void *data)
  63 {
  64     struct zebra_limit *zl = data;
  65     const struct it_key *key = buf;
  66     size_t i;
  67
  68 #if ZEBRA_LIMIT_DEBUG
  69     yaz_log(YLOG_LOG, "zebra_limit_filter_cb zl=%p key->len=%d", zl, key->len);
  70 #endif
  71     for (i = 0; zl->ids[i]; i++)
  72     {
  73 #if ZEBRA_LIMIT_DEBUG
  74         yaz_log(YLOG_LOG, " i=%d ids=" ZINT_FORMAT " mem=" ZINT_FORMAT,
  75                 i, zl->ids[i], key->mem[1]);
  76 #endif
  77         if (zl->ids[i] == key->mem[1])
  78         {
  79 #if ZEBRA_LIMIT_DEBUG
  80             yaz_log(YLOG_LOG, " match. Ret=%d", zl->complement_flag ? 0:1);
  81 #endif
  82             return zl->complement_flag ? 0 : 1;
  83         }
  84     }
  85 #if ZEBRA_LIMIT_DEBUG
  86     yaz_log(YLOG_LOG, " no match. Ret=%d", zl->complement_flag ? 1:0);
  87 #endif
  88     return zl->complement_flag ? 1 : 0;
  89 }
  90
  91 static void zebra_limit_destroy_cb(void *data)
  92 {
  93     zebra_limit_destroy(data);
  94 }
  95
  96 void zebra_limit_for_rset(struct zebra_limit *zl,
  97                           int (**filter_func)(const void *buf, void *data),
  98                           void (**filter_destroy)(void *data),
  99                           void **filter_data)
 100 {
 101 #if ZEBRA_LIMIT_DEBUG
 102     yaz_log(YLOG_LOG, "zebra_limit_for_rset debug enabled zl=%p", zl);
 103 #endif
 104     if (zl && zl->ids)
 105     {
 106         struct zebra_limit *hl;
 107
 108 #if ZEBRA_LIMIT_DEBUG
 109         yaz_log(YLOG_LOG, "enable limit");
 110 #endif
 111         hl = zebra_limit_create(zl->complement_flag, zl->ids);
 112         *filter_data = hl;
 113         *filter_func = zebra_limit_filter_cb;
 114         *filter_destroy = zebra_limit_destroy_cb;
 115     }
 116     else
 117     {
 118         *filter_data = 0;
 119         *filter_func = 0;
 120         *filter_destroy = 0;
 121     }
 122 }
 123
 124 /*
 125  * Local variables:
 126  * c-basic-offset: 4
 127  * indent-tabs-mode: nil
 128  * End:
 129  * vim: shiftwidth=4 tabstop=8 expandtab
 130  */
 131