src/marchash.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 2006-2009 Index Data
   3
   4 Pazpar2 is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 /** \file
  21     \brief MARC MAP utilities (hash lookup etc)
  22 */
  23
  24 #if HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32
  33 #include <libxml/tree.h>
  34 #include <libxml/parser.h>
  35 #include <yaz/nmem.h>
  36
  37 #include "jenkins_hash.h"
  38 #include <marchash.h>
  39
  40 inline void strtrimcat(char *dest, const char *src)
  41 {
  42     const char *in;
  43     char *out;
  44     char *last_nonspace;
  45     in = src;
  46     out = dest;
  47     // move to end of dest
  48     while (*out)
  49         out++;
  50     // initialise last non-space charater
  51     last_nonspace = out;
  52     // skip leading whitespace
  53     while (isspace(*in))
  54         in++;
  55     while (*in)
  56     {
  57         *out = *in;
  58         if (!isspace(*in))
  59             last_nonspace = out;
  60         out++;
  61         in++;
  62     }
  63     *(++last_nonspace) = '\0';
  64 }
  65
  66 inline void strtrimcpy(char *dest, const char *src)
  67 {
  68     *dest = '\0';
  69     strtrimcat(dest, src);
  70 }
  71
  72 struct marchash *marchash_create(NMEM nmem)
  73 {
  74     struct marchash *new;
  75     new = nmem_malloc(nmem, sizeof (struct marchash));
  76     memset(new, 0, sizeof (struct marchash));
  77     new->nmem = nmem;
  78     return new;
  79 }
  80
  81 void marchash_ingest_marcxml(struct marchash *marchash, xmlNodePtr rec_node)
  82 {
  83      xmlNodePtr field_node;
  84      xmlNodePtr sub_node;
  85      struct marcfield *field;
  86      field_node = rec_node->children;
  87
  88      while (field_node)
  89      {
  90          if (field_node->type == XML_ELEMENT_NODE)
  91          {
  92              field = NULL;
  93              if (!strcmp((const char *) field_node->name, "controlfield"))
  94              {
  95                  field = marchash_add_field(
  96                      marchash,
  97                      (const char *) xmlGetProp(field_node, BAD_CAST "tag"),
  98                      (const char *) xmlNodeGetContent(field_node));
  99              }
 100              else if (!strcmp((const char *) field_node->name, "datafield"))
 101              {
 102                  field = marchash_add_field(
 103                      marchash,
 104                      (const char *) xmlGetProp(field_node, BAD_CAST "tag"),
 105                      (const char *) xmlNodeGetContent(field_node));
 106              }
 107              if (field)
 108              {
 109                  sub_node = field_node->children;
 110                  while (sub_node)
 111                  {
 112                      if ((sub_node->type == XML_ELEMENT_NODE) &&
 113                          !strcmp((const char *) sub_node->name, "subfield"))
 114                      {
 115                          marchash_add_subfield(
 116                              marchash, field,
 117                              xmlGetProp(sub_node, BAD_CAST "code")[0],
 118                              (const char *) xmlNodeGetContent(sub_node));
 119                      }
 120                      sub_node = sub_node->next;
 121                  }
 122              }
 123          }
 124          field_node = field_node->next;
 125      }
 126 }
 127
 128 struct marcfield *marchash_add_field(struct marchash *marchash,
 129                                      const char *key, const char *val)
 130 {
 131     int slot;
 132     struct marcfield *new;
 133     struct marcfield *last;
 134
 135     slot = jenkins_hash((const unsigned char *) key) & MARCHASH_MASK;
 136     new = marchash->table[slot];
 137     last = NULL;
 138
 139     while (new)
 140     {
 141         last = new;
 142         new = new->next;
 143     }
 144
 145     new = nmem_malloc(marchash->nmem, sizeof (struct marcfield));
 146
 147     if (last)
 148         last->next = new;
 149     else
 150         marchash->table[slot] = new;
 151
 152     new->next = NULL;
 153     new->subfields = NULL;
 154     strncpy(new->key, key, 4);
 155
 156     // only 3 char in a marc field name
 157     if (new->key[3] != '\0')
 158         return 0;
 159
 160     new->val = nmem_malloc(marchash->nmem, sizeof (char) * strlen(val) + 1);
 161     strtrimcpy(new->val, val);
 162
 163     return new;
 164 }
 165
 166 struct marcsubfield *marchash_add_subfield(struct marchash *marchash,
 167                                            struct marcfield *field,
 168                                            const char key, const char *val)
 169 {
 170     struct marcsubfield *new;
 171     struct marcsubfield *last;
 172     last = NULL;
 173     new = field->subfields;
 174
 175     while (new)
 176     {
 177         last = new;
 178         new = new->next;
 179     }
 180
 181     new = nmem_malloc(marchash->nmem, sizeof (struct marcsubfield));
 182
 183     if (last)
 184         last->next = new;
 185     else
 186         field->subfields = new;
 187
 188     new->next = NULL;
 189     new->key = key;
 190     new->val = nmem_malloc(marchash->nmem, sizeof (char) * strlen(val) + 1);
 191     strcpy(new->val, val);
 192     return new;
 193 }
 194
 195 struct marcfield *marchash_get_field (struct marchash *marchash,
 196                                       const char *key, struct marcfield *last)
 197 {
 198     struct marcfield *cur;
 199     if (last)
 200         cur = last->next;
 201     else
 202         cur = marchash->table[jenkins_hash((const unsigned char *)key) & MARCHASH_MASK];
 203     while (cur)
 204     {
 205         if (!strcmp(cur->key, key))
 206             return cur;
 207         cur = cur->next;
 208     }
 209     return NULL;
 210 }
 211
 212 struct marcsubfield *marchash_get_subfield(char key,
 213                                            struct marcfield *field,
 214                                            struct marcsubfield *last)
 215 {
 216     struct marcsubfield *cur;
 217     if (last)
 218         cur = last->next;
 219     else
 220         cur = field->subfields;
 221     while (cur)
 222     {
 223         if (cur->key == key)
 224           return cur;
 225         cur = cur->next;
 226     }
 227     return NULL;
 228 }
 229
 230 char *marchash_catenate_subfields(struct marcfield *field,
 231                                   const char *delim, NMEM nmem)
 232 {
 233     char *output;
 234     struct marcsubfield *cur;
 235     int delimsize = strlen(delim);
 236     int outsize = 1-delimsize;
 237     // maybe it would make sense to have an nmem strcpy/strcat?
 238     cur = field -> subfields;
 239     while (cur)
 240     {
 241         outsize += strlen(cur->val) + delimsize;
 242         cur = cur->next;
 243     }
 244     if (outsize > 0)
 245         output = nmem_malloc(nmem, outsize);
 246     else
 247         return NULL;
 248     *output = '\0';
 249     cur = field -> subfields;
 250     while (cur)
 251     {
 252         strtrimcat(output, cur->val);
 253         if (cur->next)
 254             strcat(output, delim);
 255         cur = cur->next;
 256     }
 257     return output;
 258 }
 259 /*
 260  * Local variables:
 261  * c-basic-offset: 4
 262  * c-file-style: "Stroustrup"
 263  * indent-tabs-mode: nil
 264  * End:
 265  * vim: shiftwidth=4 tabstop=8 expandtab
 266  */