root/branches/stable_5.0/ARBDB/adChangeKey.c

Revision 6104, 9.3 KB (checked in by westram, 3 years ago)
  • use GB_warningf instead of GB_warning(GBS_global_string)
  • same for GB_internal_error, GB_export_error
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* =========================================================== */
2/*                                                             */
3/*   File      : adChangeKey.c                                 */
4/*   Purpose   : Changekey Management                          */
5/*                                                             */
6/*   Coded by Elmar Pruesse and Ralf Westram in May 2009       */
7/*   Institute of Microbiology (Technical University Munich)   */
8/*   http://www.arb-home.de/                                   */
9/*                                                             */
10/* =========================================================== */
11
12#include <string.h>
13#include <stdlib.h>
14
15#include <arbdb.h>
16#include <arbdbt.h>
17
18// get the container of a species key description
19GBDATA *GBT_get_changekey(GBDATA *gb_main, const char *key,
20                          const char *change_key_path) {
21#if defined(DEVEL_RALF)
22#warning check if search for CHANGEKEY_NAME should be case-sensitive!
23#endif // DEVEL_RALF
24    GBDATA *gb_key      = 0;
25    GBDATA *gb_key_data = GB_search(gb_main, change_key_path,
26                                    GB_CREATE_CONTAINER);
27
28    if (gb_key_data) {
29        GBDATA *gb_key_name = GB_find_string(gb_key_data, CHANGEKEY_NAME, key,
30                                             GB_IGNORE_CASE, down_2_level);
31        if (gb_key_name) {
32            gb_key = GB_get_father(gb_key_name);
33        }
34    }
35    return gb_key;
36}
37
38GB_TYPES GBT_get_type_of_changekey(GBDATA *gb_main, const char *field_name,
39                                   const char *change_key_path) {
40    GB_TYPES  type = GB_NONE;
41    GBDATA   *gbd  = GBT_get_changekey(gb_main,field_name, change_key_path);
42
43    if (gbd) {
44        long *typePtr     = GBT_read_int(gbd, CHANGEKEY_TYPE);
45        if (typePtr) {
46            type = (GB_TYPES)*typePtr;
47        }
48    }
49
50    return type;
51}
52
53GB_ERROR gbt_set_type_of_changekey(GBDATA *gb_main, const char *field_name, GB_TYPES type, const char *change_key_path) {
54    GB_ERROR  error = NULL;
55    GBDATA   *gbd   = GBT_get_changekey(gb_main, field_name, change_key_path);
56
57    if (!gbd) {
58        error = GBS_global_string("Can't set type of nonexistent changekey " "\"%s\"", field_name);
59    }
60    else {
61        error = GBT_write_int(gbd, CHANGEKEY_TYPE, type);
62    }
63    return error;
64}
65
66
67GB_ERROR GBT_add_new_changekey_to_keypath(GBDATA *gb_main,const char *name,
68                                          int type, const char *keypath) {
69    GB_ERROR  error  = NULL;
70    GBDATA   *gb_key = GBT_get_changekey(gb_main, name, keypath);
71    char     *c      = GB_first_non_key_char(name);
72
73    if (c) {
74        char *new_name = strdup(name);
75
76        *GB_first_non_key_char(new_name) = 0;
77
78        if (*c =='/') {
79            error = GBT_add_new_changekey(gb_main, new_name, GB_DB);
80        } else if (*c =='-') {
81            error = GBT_add_new_changekey(gb_main, new_name, GB_LINK);
82        } else {
83            error = GBS_global_string("Cannot add '%s' to your key list "
84                                      "(illegal character '%c')", name, *c);
85        }
86
87        free(new_name);
88    }
89
90    if (!error) {
91        if (!gb_key) {          // create new key
92            GBDATA *gb_key_data = GB_search(gb_main, keypath, GB_CREATE_CONTAINER);
93            gb_key = gb_key_data ?
94                GB_create_container(gb_key_data, CHANGEKEY)
95                : 0;
96            if (!gb_key) {
97                error = GB_await_error();
98            } else {
99                error = GBT_write_string(gb_key, CHANGEKEY_NAME, name);
100                if (!error)
101                    error = GBT_write_int(gb_key, CHANGEKEY_TYPE, type);
102            }
103        }
104        else {                  // check type of existing key
105            long *elem_type = GBT_read_int(gb_key, CHANGEKEY_TYPE);
106            if (!elem_type) {
107                error = GB_await_error();
108            } else if (*elem_type != type) {
109                error = GBS_global_string("Key '%s' exists, "
110                                          "but has different type", name);
111            }
112        }
113    }
114
115    gb_assert(gb_key || error);
116
117    return error;
118}
119
120GB_ERROR GBT_add_new_changekey(GBDATA *gb_main,const char *name, int type) {
121    return GBT_add_new_changekey_to_keypath(gb_main, name, type, CHANGE_KEY_PATH);
122}
123
124GB_ERROR GBT_add_new_gene_changekey(GBDATA *gb_main,const char *name, int type) {
125    return GBT_add_new_changekey_to_keypath(gb_main, name, type, CHANGE_KEY_PATH_GENES);
126}
127
128GB_ERROR GBT_add_new_experiment_changekey(GBDATA *gb_main,const char *name, int type) {
129    return GBT_add_new_changekey_to_keypath(gb_main, name, type, CHANGE_KEY_PATH_EXPERIMENTS);
130}
131
132static GB_ERROR write_as_int(GBDATA *gbfield, const char *data, GB_BOOL trimmed, size_t *rounded) {
133    char          *end   = 0;
134    unsigned long  i     = strtoul(data, &end, 10);
135    GB_ERROR       error = NULL;
136
137    if (end == data || end[0] != 0) {
138        if (trimmed) {
139            // fallback: convert to double and round
140
141            double d = strtod(data, &end);
142            if (end == data || end[0] != 0) {
143                error = GBS_global_string("cannot convert '%s' to rounded numeric value", data);
144            }
145            else {
146                (*rounded)++;
147                i                = d>0 ? (int)(d+0.5) : (int)(d-0.5);
148                error            = GB_write_int(gbfield, i);
149                if (error) error = GBS_global_string("write error (%s)", error);
150            }
151        }
152        else {
153            char *trimmed_data = GBS_trim(data);
154            error              = write_as_int(gbfield, trimmed_data, GB_TRUE, rounded);
155            free(trimmed_data);
156        }
157    }
158    else {
159        error = GB_write_int(gbfield, i);
160        if (error) error = GBS_global_string("write error (%s)", error);
161    }
162
163    return error;
164}
165
166static GB_ERROR write_as_float(GBDATA *gbfield, const char *data, GB_BOOL trimmed) {
167    char     *end   = 0;
168    double    d     = strtod(data, &end);
169    GB_ERROR  error = NULL;
170
171    if (end == data || end[0] != 0) {
172        if (trimmed) {
173            error = GBS_global_string("cannot convert '%s' to numeric value", data);
174        }
175        else {
176            char *trimmed_data = GBS_trim(data);
177            error              = write_as_float(gbfield, trimmed_data, GB_TRUE);
178            free(trimmed_data);
179        }
180    }
181    else {
182        error = GB_write_float(gbfield, d);
183        if (error) error = GBS_global_string("write error (%s)", error);
184    }
185
186    return error;
187}
188
189
190GB_ERROR GBT_convert_changekey(GBDATA *gb_main, const char *name, int target_type) {
191    GB_ERROR error        = GB_push_transaction(gb_main);
192    GB_BOOL  need_convert = GB_TRUE;
193
194    if (!error) {
195        GBDATA *gbkey = GBT_get_changekey(gb_main, name, CHANGE_KEY_PATH);
196        if (gbkey) {
197            int source_type = *GBT_read_int(gbkey, CHANGEKEY_TYPE);
198            if (source_type == target_type) need_convert = GB_FALSE;
199        }
200        else {
201            error = GBS_global_string("Unknown changekey '%s'", name);
202        }
203    }
204
205    if (!error && need_convert) {
206        GBDATA *gbspec  = GBT_first_species(gb_main);
207        size_t  rounded = 0;
208
209        for (;gbspec && !error; gbspec = GBT_next_species(gbspec)) {
210            GBDATA *gbfield = GB_entry(gbspec, name);
211
212            // If entry does not exist, no need to convert (sparse population is valid => 'NULL' value)
213            if (gbfield) {
214                char *data = GB_read_as_string(gbfield);
215                if (!data) {
216                    error = GBS_global_string("read error (%s)", GB_await_error());
217                }
218                else {
219                    error = GB_delete(gbfield);
220                    if (!error) {
221                        gbfield = GB_create(gbspec, name, target_type);
222                        if (!gbfield) {
223                            error = GBS_global_string("create error (%s)", GB_await_error());
224                        }
225                        else {
226                            switch (target_type) {
227                                case GB_INT:
228                                    error = write_as_int(gbfield, data, GB_FALSE, &rounded);
229                                    break;
230
231                                case GB_FLOAT:
232                                    error = write_as_float(gbfield, data, GB_FALSE);
233                                    break;
234
235                                case GB_STRING:
236                                    error = GB_write_string(gbfield, data);
237                                    if (error) error = GBS_global_string("write error (%s)", error);
238                                    break;
239
240                                default:
241                                    error = "Conversion is not possible";
242                                    break;
243                            }
244                        }
245                    }
246                    free(data);
247                }
248            }
249        }
250
251        if (error && gbspec) {
252            const char *spname = GBT_read_name(gbspec);
253            error              = GBS_global_string("%s for species '%s'", error, spname);
254        }
255       
256        if (!error) error = gbt_set_type_of_changekey(gb_main, name, target_type, CHANGE_KEY_PATH);
257        if (!error && rounded>0) {
258            GB_warningf("%zi values were rounded (loss of precision)", rounded);
259        }
260    }
261
262    if (error) error  = GBS_global_string("GBT_convert: %s", error);
263
264    return GB_end_transaction(gb_main, error);
265}
Note: See TracBrowser for help on using the browser.