Mercurial > audlegacy

comparison src/audacious/tuple.c @ 3510:b2a82a73a788 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Few bits of pre-integration shit.
author Matti Hamalainen <ccr@tnsp.org>
date Sun, 09 Sep 2007 16:31:50 +0300
parents 08085ecc7e91
children fb5bc40d0b86
comparison
equal deleted inserted replaced
3509:08085ecc7e91 3510:b2a82a73a788
159 } 159 }
160 160
161 return tuple; 161 return tuple;
162 } 162 }
163 163
164
165 static gint tuple_get_nfield(const gchar *field)
166 {
167 gint i;
168 for (i = 0; i < FIELD_LAST; i++)
169 if (!strcmp(field, tuple_fields[i].name))
170 return i;
171 return -1;
172 }
173
174
164 static TupleValue * 175 static TupleValue *
165 tuple_associate_data(Tuple *tuple, const gint cnfield, const gchar *field, TupleValueType ftype) 176 tuple_associate_data(Tuple *tuple, const gint cnfield, const gchar *field, TupleValueType ftype)
166 { 177 {
167 const gchar *tfield = field; 178 const gchar *tfield = field;
168 gint nfield = cnfield; 179 gint nfield = cnfield;
171 g_return_val_if_fail(tuple != NULL, NULL); 182 g_return_val_if_fail(tuple != NULL, NULL);
172 g_return_val_if_fail(cnfield < FIELD_LAST, NULL); 183 g_return_val_if_fail(cnfield < FIELD_LAST, NULL);
173 184
174 /* Check for known fields */ 185 /* Check for known fields */
175 if (nfield < 0) { 186 if (nfield < 0) {
176 gint i; 187 nfield = tuple_get_nfield(field);
177 for (i = 0; i < FIELD_LAST && nfield < 0; i++)
178 if (!strcmp(field, tuple_fields[i].name))
179 nfield = i;
180
181 if (nfield >= 0) { 188 if (nfield >= 0) {
182 fprintf(stderr, "WARNING! FIELD_* not used for '%s'!\n", field); 189 fprintf(stderr, "WARNING! FIELD_* not used for '%s'!\n", field);
183 } 190 }
184 } 191 }
185 192
207 } 214 }
208 } else { 215 } else {
209 /* Allocate a new value */ 216 /* Allocate a new value */
210 value = mowgli_heap_alloc(tuple_value_heap); 217 value = mowgli_heap_alloc(tuple_value_heap);
211 value->type = ftype; 218 value->type = ftype;
212 mowgli_dictionary_add(tuple->dict, tfield, value);
213 if (nfield >= 0) 219 if (nfield >= 0)
214 tuple->values[nfield] = value; 220 tuple->values[nfield] = value;
221 else
222 mowgli_dictionary_add(tuple->dict, tfield, value);
215 } 223 }
216 224
217 return value; 225 return value;
218 } 226 }
219 227
221 tuple_associate_string(Tuple *tuple, const gint nfield, const gchar *field, const gchar *string) 229 tuple_associate_string(Tuple *tuple, const gint nfield, const gchar *field, const gchar *string)
222 { 230 {
223 TupleValue *value; 231 TupleValue *value;
224 232
225 TUPLE_LOCK_WRITE(); 233 TUPLE_LOCK_WRITE();
226
227 if ((value = tuple_associate_data(tuple, nfield, field, TUPLE_STRING)) == NULL) 234 if ((value = tuple_associate_data(tuple, nfield, field, TUPLE_STRING)) == NULL)
228 return FALSE; 235 return FALSE;
229 236
230 if (string == NULL) 237 if (string == NULL)
231 value->value.string = NULL; 238 value->value.string = NULL;
250 TUPLE_UNLOCK_WRITE(); 257 TUPLE_UNLOCK_WRITE();
251 return TRUE; 258 return TRUE;
252 } 259 }
253 260
254 void 261 void
255 tuple_disassociate(Tuple *tuple, const gint nfield, const gchar *field) 262 tuple_disassociate(Tuple *tuple, const gint cnfield, const gchar *field)
256 { 263 {
257 TupleValue *value; 264 TupleValue *value;
258 const gchar *tfield; 265 gint nfield = cnfield;
259 266
260 g_return_if_fail(tuple != NULL); 267 g_return_if_fail(tuple != NULL);
261 g_return_if_fail(nfield < FIELD_LAST); 268 g_return_if_fail(nfield < FIELD_LAST);
262 269
263 TUPLE_LOCK_WRITE(); 270 if (nfield < 0)
264 if (nfield < 0) 271 nfield = tuple_get_nfield(field);
265 tfield = field; 272
273 TUPLE_LOCK_WRITE();
274 if (nfield < 0)
275 /* why _delete()? because _delete() returns the dictnode's data on success */
276 value = mowgli_dictionary_delete(tuple->dict, field);
266 else { 277 else {
267 tfield = tuple_fields[nfield].name; 278 value = tuple->values[nfield];
268 tuple->values[nfield] = NULL; 279 tuple->values[nfield] = NULL;
269 } 280 }
270 281
271 /* why _delete()? because _delete() returns the dictnode's data on success */ 282 if (value == NULL) {
272 if ((value = mowgli_dictionary_delete(tuple->dict, tfield)) == NULL) {
273 TUPLE_UNLOCK_WRITE(); 283 TUPLE_UNLOCK_WRITE();
274 return; 284 return;
275 } 285 }
276 286
277 /* Free associated data */ 287 /* Free associated data */
283 mowgli_heap_free(tuple_value_heap, value); 293 mowgli_heap_free(tuple_value_heap, value);
284 TUPLE_UNLOCK_WRITE(); 294 TUPLE_UNLOCK_WRITE();
285 } 295 }
286 296
287 TupleValueType 297 TupleValueType
288 tuple_get_value_type(Tuple *tuple, const gint nfield, const gchar *field) 298 tuple_get_value_type(Tuple *tuple, const gint cnfield, const gchar *field)
289 { 299 {
290 TupleValueType type = TUPLE_UNKNOWN; 300 TupleValueType type = TUPLE_UNKNOWN;
301 gint nfield = cnfield;
291 302
292 g_return_val_if_fail(tuple != NULL, TUPLE_UNKNOWN); 303 g_return_val_if_fail(tuple != NULL, TUPLE_UNKNOWN);
293 g_return_val_if_fail(nfield < FIELD_LAST, TUPLE_UNKNOWN); 304 g_return_val_if_fail(nfield < FIELD_LAST, TUPLE_UNKNOWN);
294 305
306 if (nfield < 0)
307 nfield = tuple_get_nfield(field);
308
295 TUPLE_LOCK_READ(); 309 TUPLE_LOCK_READ();
296 if (nfield < 0) { 310 if (nfield < 0) {
297 TupleValue *value; 311 TupleValue *value;
298 if ((value = mowgli_dictionary_retrieve(tuple->dict, field)) != NULL) 312 if ((value = mowgli_dictionary_retrieve(tuple->dict, field)) != NULL)
299 type = value->type; 313 type = value->type;
305 TUPLE_UNLOCK_READ(); 319 TUPLE_UNLOCK_READ();
306 return type; 320 return type;
307 } 321 }
308 322
309 const gchar * 323 const gchar *
310 tuple_get_string(Tuple *tuple, const gint nfield, const gchar *field) 324 tuple_get_string(Tuple *tuple, const gint cnfield, const gchar *field)
311 { 325 {
312 TupleValue *value; 326 TupleValue *value;
327 gint nfield = cnfield;
313 328
314 g_return_val_if_fail(tuple != NULL, NULL); 329 g_return_val_if_fail(tuple != NULL, NULL);
315 g_return_val_if_fail(nfield < FIELD_LAST, NULL); 330 g_return_val_if_fail(nfield < FIELD_LAST, NULL);
316 331
332 if (nfield < 0)
333 nfield = tuple_get_nfield(field);
334
317 TUPLE_LOCK_READ(); 335 TUPLE_LOCK_READ();
318 if (nfield < 0) 336 if (nfield < 0)
319 value = mowgli_dictionary_retrieve(tuple->dict, field); 337 value = mowgli_dictionary_retrieve(tuple->dict, field);
320 else 338 else
321 value = tuple->values[nfield]; 339 value = tuple->values[nfield];
331 return NULL; 349 return NULL;
332 } 350 }
333 } 351 }
334 352
335 gint 353 gint
336 tuple_get_int(Tuple *tuple, const gint nfield, const gchar *field) 354 tuple_get_int(Tuple *tuple, const gint cnfield, const gchar *field)
337 { 355 {
338 TupleValue *value; 356 TupleValue *value;
357 gint nfield = cnfield;
339 358
340 g_return_val_if_fail(tuple != NULL, 0); 359 g_return_val_if_fail(tuple != NULL, 0);
341 g_return_val_if_fail(nfield < FIELD_LAST, 0); 360 g_return_val_if_fail(nfield < FIELD_LAST, 0);
342 361
362 if (nfield < 0)
363 nfield = tuple_get_nfield(field);
364
343 TUPLE_LOCK_READ(); 365 TUPLE_LOCK_READ();
344 if (nfield < 0) 366 if (nfield < 0)
345 value = mowgli_dictionary_retrieve(tuple->dict, field); 367 value = mowgli_dictionary_retrieve(tuple->dict, field);
346 else 368 else
347 value = tuple->values[nfield]; 369 value = tuple->values[nfield];