index/limit.c

   1 /* $Id: limit.c,v 1.6 2005-11-29 09:37:04 adam Exp $
   2    Copyright (C) 1995-2005
   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 #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     if (key->len != 3)
  72         return 1;
  73     for (i = 0; zl->ids[i]; i++)
  74     {
  75 #if ZEBRA_LIMIT_DEBUG
  76         yaz_log(YLOG_LOG, " i=%d ids=" ZINT_FORMAT " mem=" ZINT_FORMAT,
  77                 i, zl->ids[i], key->mem[1]);
  78 #endif
  79         if (zl->ids[i] == key->mem[1])
  80         {
  81 #if ZEBRA_LIMIT_DEBUG
  82             yaz_log(YLOG_LOG, " match. Ret=%d", zl->complement_flag ? 0:1);
  83 #endif
  84             return zl->complement_flag ? 0 : 1;
  85         }
  86     }
  87 #if ZEBRA_LIMIT_DEBUG
  88     yaz_log(YLOG_LOG, " no match. Ret=%d", zl->complement_flag ? 1:0);
  89 #endif
  90     return zl->complement_flag ? 1 : 0;
  91 }
  92
  93 static void zebra_limit_destroy_cb(void *data)
  94 {
  95     zebra_limit_destroy(data);
  96 }
  97
  98 void zebra_limit_for_rset(struct zebra_limit *zl,
  99                           int (**filter_func)(const void *buf, void *data),
 100                           void (**filter_destroy)(void *data),
 101                           void **filter_data)
 102 {
 103 #if ZEBRA_LIMIT_DEBUG
 104     yaz_log(YLOG_LOG, "zebra_limit_for_rset debug enabled zl=%p", zl);
 105 #endif
 106     if (zl && zl->ids)
 107     {
 108         struct zebra_limit *hl;
 109
 110 #if ZEBRA_LIMIT_DEBUG
 111         yaz_log(YLOG_LOG, "enable limit");
 112 #endif
 113         hl = zebra_limit_create(zl->complement_flag, zl->ids);
 114         *filter_data = hl;
 115         *filter_func = zebra_limit_filter_cb;
 116         *filter_destroy = zebra_limit_destroy_cb;
 117     }
 118     else
 119     {
 120         *filter_data = 0;
 121         *filter_func = 0;
 122         *filter_destroy = 0;
 123     }
 124 }
 125