lib/index.h

   1 /*
   2  *      Sherlock: Data structures used in indices
   3  *
   4  *      (c) 2001--2002 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #ifndef _SHERLOCK_INDEX_H
   8 #define _SHERLOCK_INDEX_H
   9
  10 #include "lib/fastbuf.h"
  11 #include "charset/unistream.h"
  12
  13 /* Words */
  14
  15 #define MAX_WORD_LEN            64
  16
  17 /* Word and string types are defined in lib/custom.h */
  18
  19 /* Global index parameters */
  20
  21 struct index_params {
  22   sh_time_t ref_time;                   /* Reference time (for document ages etc.) */
  23 };
  24
  25 /* Index card attributes */
  26
  27 struct card_attr {
  28   u32 card;                             /* Reference to card description (either oid or filepos) */
  29   u32 site_id;
  30 #define INT_ATTR(t,i,o,k,g,p) t i;
  31   CUSTOM_ATTRS                          /* Include all custom attributes */
  32 #undef INT_ATTR
  33   byte weight;
  34   byte flags;
  35   byte age;                             /* Document age in pseudo-logarithmic units wrt. reference time */
  36   // byte rfu[1];                       /* If no custom attributes are defined */
  37 };
  38
  39 enum card_flag {
  40   CARD_FLAG_EMPTY = 1,                  /* Empty document (redirect, robot file etc.) [scanner] */
  41   CARD_FLAG_ACCENTED = 2,               /* Document contains accented characters [scanner] */
  42   CARD_FLAG_DUP = 4,                    /* Removed as a duplicate [merger] */
  43   CARD_FLAG_MERGED = 8,                 /* Destination of a merge [merger] */
  44   CARD_FLAG_IMAGE = 16,                 /* Is an image object [scanner] */
  45 };
  46
  47 #define CARD_POS_SHIFT 5                /* Card positions are shifted this # of bytes to the right */
  48
  49 /* String fingerprints */
  50
  51 struct fingerprint {
  52   byte hash[12];
  53 };
  54
  55 void fingerprint(byte *string, struct fingerprint *fp);
  56
  57 static inline u32
  58 fp_hash(struct fingerprint *fp)
  59 {
  60   return (fp->hash[0] << 24) | (fp->hash[1] << 16) | (fp->hash[2] << 8) | fp->hash[3];
  61 }
  62
  63 /* Reading of tagged text (Unicode values, tags mapped to 0x80000000 and higher) */
  64
  65 #define GET_TAGGED_CHAR(p,u) do {                               \
  66   u = *p;                                                       \
  67   if (u >= 0xc0)                                                \
  68     GET_UTF8_CHAR(p,u);                                         \
  69   else if (u >= 0x80)                                           \
  70     {                                                           \
  71       p++;                                                      \
  72       if (u >= 0xb0)                                            \
  73         {                                                       \
  74           ASSERT(u == 0xb0);                                    \
  75           u += 0x80020000;                                      \
  76         }                                                       \
  77       else if (u >= 0xa0)                                       \
  78         {                                                       \
  79           ASSERT(*p >= 0x80 && *p <= 0xbf);                     \
  80           u = 0x80010000 + ((u & 0x0f) << 6) + (*p++ & 0x3f);   \
  81         }                                                       \
  82       else                                                      \
  83         u += 0x80000000;                                        \
  84     }                                                           \
  85   else                                                          \
  86     p++;                                                        \
  87 } while (0)
  88
  89 static inline uns
  90 bget_tagged_char(struct fastbuf *f)
  91 {
  92   uns u = bgetc(f);
  93   if ((int)u < 0x80)
  94     ;
  95   else if (u < 0xc0)
  96     {
  97       if (u >= 0xb0)
  98         {
  99           ASSERT(u == 0xb0);
 100           u += 0x80020000;
 101         }
 102       else if (u >= 0xa0)
 103         {
 104           uns v = bgetc(f);
 105           ASSERT(v >= 0x80 && v <= 0xbf);
 106           u = 0x80010000 + ((u & 0x0f) << 6) + (v & 0x3f);
 107         }
 108       else
 109         u += 0x80000000;
 110     }
 111   else
 112     {
 113       bungetc(f);
 114       u = bget_utf8(f);
 115     }
 116   return u;
 117 }
 118
 119 /* Conversion of document age from seconds to our internal units */
 120
 121 static inline int
 122 convert_age(sh_time_t lastmod, sh_time_t reftime)
 123 {
 124   sh_time_t age;
 125   if (reftime < lastmod)                /* past times */
 126     return -1;
 127   age = (reftime - lastmod) / 3600;
 128   if (age < 48)                         /* last 2 days: 1 hour resolution */
 129     return age;
 130   age = (age-48) / 24;
 131   if (age < 64)                         /* next 64 days: 1 day resolution */
 132     return 48 + age;
 133   age = (age-64) / 7;
 134   if (age < 135)                        /* next 135 weeks: 1 week resolution */
 135     return 112 + age;
 136   age = (age-135) / 52;
 137   if (age < 8)                          /* next 8 years: 1 year resolution */
 138     return 247 + age;
 139   return 255;                           /* then just "infinite future" */
 140 }
 141
 142 #endif