d8e0ff13acf353de7f72d344b34087175f9f02ad
[pazpar2-moved-to-github.git] / src / record.c
1 /* $Id: record.c,v 1.4 2007-04-24 13:50:07 marc Exp $
2    Copyright (c) 2006-2007, Index Data.
3
4 This file is part of Pazpar2.
5
6 Pazpar2 is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2, or (at your option) any later
9 version.
10
11 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with Pazpar2; see the file LICENSE.  If not, write to the
18 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA.
20  */
21
22 /* $Id: record.c,v 1.4 2007-04-24 13:50:07 marc Exp $ */
23
24
25 #include <string.h>
26
27 #include <yaz/yaz-util.h>
28 #include <yaz/nmem.h>
29
30 #if HAVE_CONFIG_H
31 #include <cconfig.h>
32 #endif
33
34 //#define CONFIG_NOEXTERNS
35 #include "config.h"
36 #include "record.h"
37
38
39
40 union data_types * data_types_assign(NMEM nmem, 
41                                      union data_types * data1, 
42                                      union data_types data2)
43 {
44     // assert(nmem);
45
46     if (!data1){
47         if (!nmem)
48             return 0;
49         else
50             data1  = nmem_malloc(nmem, sizeof(union data_types));
51     }
52     
53     *data1 = data2;
54     return data1;
55 }
56
57
58 struct record * record_create(NMEM nmem, int num_metadata, int num_sortkeys)
59 {
60     struct record * record = 0;
61     
62     // assert(nmem);
63
64     record = nmem_malloc(nmem, sizeof(struct record));
65
66     record->next = 0;
67     // which client should I use for record->client = cl;  ??
68     record->client = 0;
69
70     record->metadata 
71         = nmem_malloc(nmem, 
72                       sizeof(struct record_metadata*) * num_metadata);
73     //memset(record->metadata, 0, 
74     //((       sizeof(struct record_metadata*) * num_metadata);
75     
76     record->sortkeys  
77         = nmem_malloc(nmem, 
78                       sizeof(union data_types*) * num_sortkeys);
79      //memset(record->metadata, 0, 
80      //      sizeof(union data_types*) * num_sortkeys);
81     
82     
83     return record;
84 }
85
86
87 struct record_metadata * record_metadata_insert(NMEM nmem, 
88                                                 struct record_metadata ** rmd,
89                                                 union data_types data)
90 {
91     struct record_metadata * tmp_rmd = 0;
92     // assert(nmem);
93
94     if(!rmd)
95         return 0;
96
97     // construct new record_metadata
98     tmp_rmd  = nmem_malloc(nmem, sizeof(struct record_metadata));
99     tmp_rmd->data = data;
100
101
102     // insert in *rmd's place
103     tmp_rmd->next = *rmd;
104     *rmd = tmp_rmd;
105
106     return tmp_rmd;
107 }
108
109 struct record_metadata * record_add_metadata_field_id(NMEM nmem, 
110                                                      struct record * record,
111                                                      int field_id, 
112                                                      union data_types data)
113 {
114     if (field_id < 0 || !record || !record->metadata)
115         return 0;
116
117     return record_metadata_insert(nmem, &(record->metadata[field_id]), data);
118 }
119
120
121 struct record_metadata * record_add_metadata(NMEM nmem, 
122                                              struct record * record,
123                                              struct conf_service * service,
124                                              const char * name,
125                                              union data_types data)
126 {
127     int field_id = 0;
128
129     if (!record || !record->metadata || !service || !name)  
130         return 0;
131     
132     field_id = conf_service_metadata_field_id(service, name);
133
134     if (-1 == field_id)
135         return 0;
136     
137     return record_metadata_insert(nmem, &(record->metadata[field_id]), data);
138 }
139
140
141
142
143
144
145 union data_types * record_assign_sortkey_field_id(NMEM nmem, 
146                                                struct record * record,
147                                                int field_id, 
148                                                union data_types data)
149 {
150     if (field_id < 0 || !record || !record->sortkeys)
151         return 0;
152
153     return data_types_assign(nmem, record->sortkeys[field_id], data);
154 }
155
156
157
158 union data_types * record_assign_sortkey(NMEM nmem, 
159                                       struct record * record,
160                                       struct conf_service * service,
161                                       const char * name,
162                                       union data_types data)
163 {
164     int field_id = 0;
165
166     if (!record || !service || !name)  
167         return 0;
168     
169     field_id = conf_service_sortkey_field_id(service, name);
170
171     if (!(field_id < service->num_sortkeys))
172         return 0;
173
174     return record_assign_sortkey_field_id(nmem, record, field_id, data);
175 }
176
177
178
179 /*
180  * Local variables:
181  * c-basic-offset: 4
182  * indent-tabs-mode: nil
183  * End:
184  * vim: shiftwidth=4 tabstop=8 expandtab
185  */