Add include of config.h
[pazpar2-moved-to-github.git] / 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  */