Context Navigation

source: tags/arb_5.1/ARBDB/adChangeKey.c

Visit:

Last change on this file was 6104, checked in by westram, 15 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`
File size: 9.3 KB

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
19	GBDATA 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
38	GB_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
53	GB_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
67	GB_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
120	GB_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
124	GB_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
128	GB_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
132	static 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
166	static 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
190	GB_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	}
266

Note: See TracBrowser for help on using the repository browser.

Download in other formats: