← Back to branch summary

~ubuntu-branches/ubuntu/saucy/xmms2/saucy-proposed

« back to all changes in this revision

Viewing changes to src/lib/xmmstypes/coll.c

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2011-10-22 23:53:00 UTC
  • mto: (38.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 43.
  • Revision ID: james.westby@ubuntu.com-20111022235300-u50pdo3g341jvk7q
Import upstream version 0.8+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/xmmstypes/coll.c
1
1
/*  XMMS2 - X Music Multiplexer System
2
 
 *  Copyright (C) 2003-2009 XMMS2 Team
 
2
 *  Copyright (C) 2003-2011 XMMS2 Team
3
3
 *
4
4
 *  PLUGINS ARE NOT CONSIDERED TO BE DERIVED WORK !!!
5
5
 *
34
34
        xmmsv_coll_type_t type;
35
35
        xmmsv_t *operands;
36
36
        xmmsv_t *attributes;
37
 
 
38
 
        /* List of ids, 0-terminated. */
39
 
        uint32_t *idlist;
40
 
        size_t idlist_size;
41
 
        size_t idlist_allocated;
42
 
 
 
37
        xmmsv_t *idlist;
 
38
 
 
39
        int32_t *legacy_idlist;
43
40
};
44
41
 
45
42
 
46
43
static void xmmsv_coll_free (xmmsv_coll_t *coll);
47
44
 
48
 
static int xmmsv_coll_idlist_resize (xmmsv_coll_t *coll, size_t newsize);
49
 
 
50
45
 
51
46
/**
52
47
 * @defgroup CollectionStructure CollectionStructure
92
87
                return NULL;
93
88
        }
94
89
 
95
 
        if (!(coll->idlist = x_new0 (uint32_t, 1))) {
96
 
                x_oom ();
97
 
                free (coll);
98
 
                return NULL;
99
 
        }
100
 
        coll->idlist_size = 1;
101
 
        coll->idlist_allocated = 1;
102
 
 
103
90
        coll->ref  = 0;
104
91
        coll->type = type;
105
92
 
 
93
        coll->idlist = xmmsv_new_list ();
 
94
        xmmsv_list_restrict_type (coll->idlist, XMMSV_TYPE_INT32);
 
95
 
106
96
        coll->operands = xmmsv_new_list ();
107
97
        xmmsv_list_restrict_type (coll->operands, XMMSV_TYPE_COLL);
108
98
 
109
99
        coll->attributes = xmmsv_new_dict ();
110
100
 
 
101
        coll->legacy_idlist = NULL;
 
102
 
111
103
        /* user must give this back */
112
104
        xmmsv_coll_ref (coll);
113
105
 
128
120
 
129
121
        /* Unref all the operands and attributes */
130
122
        xmmsv_unref (coll->operands);
131
 
 
132
123
        xmmsv_unref (coll->attributes);
133
 
 
134
 
        free (coll->idlist);
 
124
        xmmsv_unref (coll->idlist);
 
125
        if (coll->legacy_idlist) {
 
126
                free (coll->legacy_idlist);
 
127
        }
135
128
 
136
129
        free (coll);
137
130
}
165
158
 * @param ids  the 0-terminated list of ids to store in the collection.
166
159
 */
167
160
void
168
 
xmmsv_coll_set_idlist (xmmsv_coll_t *coll, unsigned int ids[])
 
161
xmmsv_coll_set_idlist (xmmsv_coll_t *coll, int ids[])
169
162
{
170
163
        unsigned int i;
171
 
        unsigned int size = 0;
172
 
 
173
 
        x_return_if_fail (coll);
174
 
 
175
 
        while (ids[size] != 0) {
176
 
                ++size;
177
 
        }
178
 
        ++size;
179
 
 
180
 
        free (coll->idlist);
181
 
        if (!(coll->idlist = x_new0 (uint32_t, size))) {
182
 
                x_oom ();
183
 
                return;
184
 
        }
185
 
 
186
 
        for (i = 0; i < size; ++i) {
187
 
                coll->idlist[i] = ids[i];
188
 
        }
189
 
 
190
 
        coll->idlist_size = size;
191
 
        coll->idlist_allocated = size;
 
164
 
 
165
        xmmsv_list_clear (coll->idlist);
 
166
        for (i = 0; ids[i]; i++) {
 
167
                xmmsv_list_append_int (coll->idlist, ids[i]);
 
168
        }
192
169
}
193
170
 
194
171
static int
272
249
 * @return  TRUE on success, false otherwise.
273
250
 */
274
251
int
275
 
xmmsv_coll_idlist_append (xmmsv_coll_t *coll, unsigned int id)
 
252
xmmsv_coll_idlist_append (xmmsv_coll_t *coll, int id)
276
253
{
277
254
        x_return_val_if_fail (coll, 0);
278
255
 
279
 
        return xmmsv_coll_idlist_insert (coll, coll->idlist_size - 1, id);
 
256
        return xmmsv_list_append_int (coll->idlist, id);
280
257
}
281
258
 
282
259
/**
287
264
 * @return  TRUE on success, false otherwise.
288
265
 */
289
266
int
290
 
xmmsv_coll_idlist_insert (xmmsv_coll_t *coll, unsigned int index, unsigned int id)
 
267
xmmsv_coll_idlist_insert (xmmsv_coll_t *coll, int index, int id)
291
268
{
292
 
        int i;
293
269
        x_return_val_if_fail (coll, 0);
294
270
 
295
 
        if (index >= coll->idlist_size) {
296
 
                return 0;
297
 
        }
298
 
 
299
 
        /* We need more memory, reallocate */
300
 
        if (coll->idlist_size == coll->idlist_allocated) {
301
 
                int success;
302
 
                size_t double_size = coll->idlist_allocated * 2;
303
 
                success = xmmsv_coll_idlist_resize (coll, double_size);
304
 
                x_return_val_if_fail (success, 0);
305
 
        }
306
 
 
307
 
        for (i = coll->idlist_size; i > index; i--) {
308
 
                coll->idlist[i] = coll->idlist[i - 1];
309
 
        }
310
 
 
311
 
        coll->idlist[index] = id;
312
 
        coll->idlist_size++;
313
 
 
314
 
        return 1;
 
271
        return xmmsv_list_insert_int (coll->idlist, index, id);
315
272
}
316
273
 
317
274
/**
322
279
 * @return  TRUE on success, false otherwise.
323
280
 */
324
281
int
325
 
xmmsv_coll_idlist_move (xmmsv_coll_t *coll, unsigned int index, unsigned int newindex)
 
282
xmmsv_coll_idlist_move (xmmsv_coll_t *coll, int index, int newindex)
326
283
{
327
 
        int i;
328
 
        uint32_t tmp;
329
 
 
330
284
        x_return_val_if_fail (coll, 0);
331
285
 
332
 
        if ((index >= coll->idlist_size - 1) || (newindex >= coll->idlist_size - 1)) {
333
 
                return 0;
334
 
        }
335
 
 
336
 
        tmp = coll->idlist[index];
337
 
        if (index < newindex) {
338
 
                for (i = index; i < newindex; i++) {
339
 
                        coll->idlist[i] = coll->idlist[i + 1];
340
 
                }
341
 
        }
342
 
        else if (index > newindex) {
343
 
                for (i = index; i > newindex; i--) {
344
 
                        coll->idlist[i] = coll->idlist[i - 1];
345
 
                }
346
 
        }
347
 
        coll->idlist[newindex] = tmp;
348
 
 
349
 
        return 1;
 
286
        return xmmsv_list_move (coll->idlist, index, newindex);
350
287
}
351
288
 
352
289
/**
356
293
 * @return  TRUE on success, false otherwise.
357
294
 */
358
295
int
359
 
xmmsv_coll_idlist_remove (xmmsv_coll_t *coll, unsigned int index)
 
296
xmmsv_coll_idlist_remove (xmmsv_coll_t *coll, int index)
360
297
{
361
 
        int i;
362
 
        size_t half_size;
363
 
 
364
298
        x_return_val_if_fail (coll, 0);
365
299
 
366
 
        if (index >= coll->idlist_size - 1) {
367
 
                return 0;
368
 
        }
369
 
 
370
 
        coll->idlist_size--;
371
 
        for (i = index; i < coll->idlist_size; i++) {
372
 
                coll->idlist[i] = coll->idlist[i + 1];
373
 
        }
374
 
 
375
 
        /* Reduce memory usage by two if possible */
376
 
        half_size = coll->idlist_allocated / 2;
377
 
        if (coll->idlist_size <= half_size) {
378
 
                xmmsv_coll_idlist_resize (coll, half_size);
379
 
        }
380
 
 
381
 
        return 1;
 
300
        return xmmsv_list_remove (coll->idlist, index);
382
301
}
383
302
 
384
303
/**
389
308
int
390
309
xmmsv_coll_idlist_clear (xmmsv_coll_t *coll)
391
310
{
392
 
        unsigned int empty[] = { 0 };
393
 
 
394
311
        x_return_val_if_fail (coll, 0);
395
312
 
396
 
        xmmsv_coll_set_idlist (coll, empty);
397
 
 
398
 
        return 1;
 
313
        return xmmsv_list_clear (coll->idlist);
399
314
}
400
315
 
401
316
/**
406
321
 * @return  TRUE on success, false otherwise.
407
322
 */
408
323
int
409
 
xmmsv_coll_idlist_get_index (xmmsv_coll_t *coll, unsigned int index, uint32_t *val)
 
324
xmmsv_coll_idlist_get_index (xmmsv_coll_t *coll, int index, int32_t *val)
410
325
{
411
326
        x_return_val_if_fail (coll, 0);
412
327
 
413
 
        if (index >= (coll->idlist_size - 1)) {
414
 
                return 0;
415
 
        }
416
 
 
417
 
        *val = coll->idlist[index];
418
 
 
419
 
        return 1;
 
328
        return xmmsv_list_get_int (coll->idlist, index, val);
420
329
}
421
330
 
422
331
/**
427
336
 * @return  TRUE on success, false otherwise.
428
337
 */
429
338
int
430
 
xmmsv_coll_idlist_set_index (xmmsv_coll_t *coll, unsigned int index, uint32_t val)
 
339
xmmsv_coll_idlist_set_index (xmmsv_coll_t *coll, int index, int32_t val)
431
340
{
432
341
        x_return_val_if_fail (coll, 0);
433
342
 
434
 
        if (index >= (coll->idlist_size - 1)) {
435
 
                return 0;
436
 
        }
437
 
 
438
 
        coll->idlist[index] = val;
439
 
 
440
 
        return 1;
 
343
        return xmmsv_list_set_int (coll->idlist, index, val);
441
344
}
442
345
 
443
346
/**
450
353
{
451
354
        x_return_val_if_fail (coll, 0);
452
355
 
453
 
        return coll->idlist_size - 1;
 
356
        return xmmsv_list_get_size (coll->idlist);
454
357
}
455
358
 
456
359
 
474
377
 * Note that this must not be confused with the content of the
475
378
 * collection, which must be queried using xmmsc_coll_query_ids!
476
379
 *
 
380
 * Also note that this function is deprecated (use xmmsv_coll_idlist_get
 
381
 * instead) and that changes to the returned array will be ignored. The array
 
382
 * is also not updated when the idlist is changed using the supplied functions.
 
383
 * Additionally every call to this function allocates a new array, so calling
 
384
 * it repetitively will be a performance penalty.
 
385
 *
477
386
 * @param coll  The collection to consider.
478
387
 * @return The 0-terminated list of ids.
479
388
 */
480
 
uint32_t*
 
389
const int32_t*
481
390
xmmsv_coll_get_idlist (xmmsv_coll_t *coll)
482
391
{
 
392
        xmmsv_list_iter_t *it;
 
393
        unsigned int i;
 
394
        int32_t entry;
 
395
 
 
396
        x_return_null_if_fail (coll);
 
397
 
 
398
        /* free and allocate a new legacy list */
 
399
        if (coll->legacy_idlist) {
 
400
                free (coll->legacy_idlist);
 
401
        }
 
402
        coll->legacy_idlist = calloc (xmmsv_coll_idlist_get_size (coll) + 1,
 
403
                                      sizeof (int32_t));
 
404
 
 
405
        /* copy contents to legacy list */
 
406
        for (xmmsv_get_list_iter (coll->idlist, &it), i = 0;
 
407
             xmmsv_list_iter_valid (it);
 
408
             xmmsv_list_iter_next (it), i++) {
 
409
                xmmsv_list_iter_entry_int (it, &entry);
 
410
                coll->legacy_idlist[i] = entry;
 
411
        }
 
412
        coll->legacy_idlist[i] = 0;
 
413
 
 
414
        return coll->legacy_idlist;
 
415
}
 
416
 
 
417
/**
 
418
 * Return the list of ids stored in the collection.
 
419
 * This function does not increase the refcount of the list, the reference is
 
420
 * still owned by the collection.
 
421
 *
 
422
 * Note that this must not be confused with the content of the collection,
 
423
 * which must be queried using xmmsc_coll_query_ids!
 
424
 *
 
425
 * @param coll  The collection to consider.
 
426
 * @return The 0-terminated list of ids.
 
427
 */
 
428
xmmsv_t *
 
429
xmmsv_coll_idlist_get (xmmsv_coll_t *coll)
 
430
{
483
431
        x_return_null_if_fail (coll);
484
432
 
485
433
        return coll->idlist;
614
562
}
615
563
 
616
564
/** @} */
617
 
 
618
 
 
619
 
 
620
 
/** @internal */
621
 
 
622
 
 
623
 
static int
624
 
xmmsv_coll_idlist_resize (xmmsv_coll_t *coll, size_t newsize)
625
 
{
626
 
        uint32_t *newmem;
627
 
 
628
 
        newmem = realloc (coll->idlist, newsize * sizeof (uint32_t));
629
 
 
630
 
        if (newmem == NULL) {
631
 
                x_oom ();
632
 
                return 0;
633
 
        }
634
 
 
635
 
        coll->idlist = newmem;
636
 
        coll->idlist_allocated = newsize;
637
 
 
638
 
        return 1;
639
 
}