XMMS2
value_serialize.c
Go to the documentation of this file.
1/* XMMS2 - X Music Multiplexer System
2 * Copyright (C) 2003-2011 XMMS2 Team
3 *
4 * PLUGINS ARE NOT CONSIDERED TO BE DERIVED WORK !!!
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 */
16
17#include <string.h>
18
19#include "xmmsc/xmmsc_stdbool.h"
20#include "xmmsc/xmmsc_util.h"
21#include "xmmsc/xmmsv.h"
22#include "xmmsclientpriv/xmmsclient_util.h"
23
24static bool _internal_put_on_bb_bin (xmmsv_t *bb, const unsigned char *data, unsigned int len);
25static bool _internal_put_on_bb_error (xmmsv_t *bb, const char *errmsg);
26static bool _internal_put_on_bb_int32 (xmmsv_t *bb, int32_t v);
27static bool _internal_put_on_bb_string (xmmsv_t *bb, const char *str);
28static bool _internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll);
29static bool _internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v);
30static bool _internal_put_on_bb_value_dict (xmmsv_t *bb, xmmsv_t *v);
31
32static bool _internal_get_from_bb_error_alloc (xmmsv_t *bb, char **buf, unsigned int *len);
33static bool _internal_get_from_bb_int32 (xmmsv_t *bb, int32_t *v);
34static bool _internal_get_from_bb_int32_positive (xmmsv_t *bb, int32_t *v);
35static bool _internal_get_from_bb_string_alloc (xmmsv_t *bb, char **buf, unsigned int *len);
36static bool _internal_get_from_bb_collection_alloc (xmmsv_t *bb, xmmsv_coll_t **coll);
37static bool _internal_get_from_bb_bin_alloc (xmmsv_t *bb, unsigned char **buf, unsigned int *len);
38
39static bool _internal_get_from_bb_value_of_type_alloc (xmmsv_t *bb, xmmsv_type_t type, xmmsv_t **val);
40
41
42static void
43_internal_put_on_bb_append_coll_attr (const char *key, xmmsv_t *value, void *userdata)
44{
45 xmmsv_t *bb = (xmmsv_t *)userdata;
46 const char *s;
47 int r;
48
49 r = xmmsv_get_string (value, &s);
51
52 _internal_put_on_bb_string (bb, key);
53 _internal_put_on_bb_string (bb, s);
54}
55
56static void
57_internal_put_on_bb_count_coll_attr (const char *key, xmmsv_t *value, void *userdata)
58{
59 int *n = (int *)userdata;
60 ++(*n);
61}
62
63static bool
64_internal_put_on_bb_bin (xmmsv_t *bb,
65 const unsigned char *data,
66 unsigned int len)
67{
68 if (!xmmsv_bitbuffer_put_bits (bb, 32, len))
69 return false;
70
71 return xmmsv_bitbuffer_put_data (bb, data, len);
72}
73
74static bool
75_internal_put_on_bb_error (xmmsv_t *bb, const char *errmsg)
76{
77 if (!bb) {
78 return -1;
79 }
80
81 if (!errmsg) {
82 return xmmsv_bitbuffer_put_bits (bb, 32, 0);
83 }
84
85 if (!xmmsv_bitbuffer_put_bits (bb, 32, strlen (errmsg) + 1))
86 return false;
87
88 return xmmsv_bitbuffer_put_data (bb, (const unsigned char *) errmsg, strlen (errmsg) + 1);
89}
90
91static bool
92_internal_put_on_bb_int32 (xmmsv_t *bb, int32_t v)
93{
94 return xmmsv_bitbuffer_put_bits (bb, 32, v);
95}
96
97static bool
98_internal_put_on_bb_string (xmmsv_t *bb, const char *str)
99{
100 if (!bb) {
101 return false;
102 }
103
104 if (!str) {
105 return xmmsv_bitbuffer_put_bits (bb, 32, 0);
106 }
107
108 if (!xmmsv_bitbuffer_put_bits (bb, 32, strlen (str) + 1))
109 return false;
110
111 return xmmsv_bitbuffer_put_data (bb, (const unsigned char *) str, strlen (str) + 1);
112}
113
114static bool
115_internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
116{
118 xmmsv_t *v, *attrs;
119 int n;
120 uint32_t ret;
121 int32_t entry;
122 xmmsv_coll_t *op;
123
124 if (!bb || !coll) {
125 return false;
126 }
127
128 /* push type */
129 if (!xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_get_type (coll)))
130 return false;
131
132 /* attribute counter and values */
133 attrs = xmmsv_coll_attributes_get (coll);
134 n = 0;
135
136 xmmsv_dict_foreach (attrs, _internal_put_on_bb_count_coll_attr, &n);
137 if (!xmmsv_bitbuffer_put_bits (bb, 32, n))
138 return false;
139
140 /* needs error checking! */
141 xmmsv_dict_foreach (attrs, _internal_put_on_bb_append_coll_attr, bb);
142
143 attrs = NULL; /* no unref needed. */
144
145 /* idlist counter and content */
147
149 for (xmmsv_list_iter_first (it);
152
153 if (!xmmsv_list_iter_entry_int (it, &entry)) {
154 x_api_error ("Non integer in idlist", 0);
155 }
156 xmmsv_bitbuffer_put_bits (bb, 32, entry);
157 }
159
160 /* operands counter and objects */
161 n = 0;
164 }
165
166 ret = xmmsv_bitbuffer_pos (bb);
167 xmmsv_bitbuffer_put_bits (bb, 32, n);
168
169 if (n > 0) {
171
172 while (xmmsv_list_iter_entry (it, &v)) {
173 if (!xmmsv_get_coll (v, &op)) {
174 x_api_error ("Non collection operand", 0);
175 }
176
177 _internal_put_on_bb_int32 (bb, XMMSV_TYPE_COLL);
178
179 ret = _internal_put_on_bb_collection (bb, op);
181 }
182 }
183
184 return ret;
185}
186
187static bool
188_internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v)
189{
191 xmmsv_t *entry;
192 uint32_t offset, count;
193 bool ret = true;
194
195 if (!xmmsv_get_list_iter (v, &it)) {
196 return false;
197 }
198
199 /* store a dummy value, store the real count once it's known */
200 offset = xmmsv_bitbuffer_pos (bb);
201 xmmsv_bitbuffer_put_bits (bb, 32, 0);
202
203 count = 0;
204 while (xmmsv_list_iter_valid (it)) {
205 xmmsv_list_iter_entry (it, &entry);
206 ret = xmmsv_bitbuffer_serialize_value (bb, entry);
208 count++;
209 }
210
211 /* overwrite with real size */
212 xmmsv_bitbuffer_put_bits_at (bb, 32, count, offset);
213
214 return ret;
215}
216
217static bool
218_internal_put_on_bb_value_dict (xmmsv_t *bb, xmmsv_t *v)
219{
221 const char *key;
222 xmmsv_t *entry;
223 uint32_t ret, offset, count;
224
225 if (!xmmsv_get_dict_iter (v, &it)) {
226 return false;
227 }
228
229 /* store a dummy value, store the real count once it's known */
230 offset = xmmsv_bitbuffer_pos (bb);
231 xmmsv_bitbuffer_put_bits (bb, 32, 0);
232
233 count = 0;
234 while (xmmsv_dict_iter_valid (it)) {
235 xmmsv_dict_iter_pair (it, &key, &entry);
236 ret = _internal_put_on_bb_string (bb, key);
237 ret = xmmsv_bitbuffer_serialize_value (bb, entry);
239 count++;
240 }
241
242 /* overwrite with real size */
243 xmmsv_bitbuffer_put_bits_at (bb, 32, count, offset);
244
245 return ret;
246}
247
248static bool
249_internal_get_from_bb_data (xmmsv_t *bb, void *buf, unsigned int len)
250{
251 if (!bb)
252 return false;
253
254 return xmmsv_bitbuffer_get_data (bb, buf, len);
255}
256
257static bool
258_internal_get_from_bb_error_alloc (xmmsv_t *bb, char **buf,
259 unsigned int *len)
260{
261 /* currently, an error is just a string, so reuse that */
262 return _internal_get_from_bb_string_alloc (bb, buf, len);
263}
264
265static bool
266_internal_get_from_bb_int32 (xmmsv_t *bb, int32_t *v)
267{
268 return xmmsv_bitbuffer_get_bits (bb, 32, v);
269}
270
271static bool
272_internal_get_from_bb_int32_positive (xmmsv_t *bb, int32_t *v)
273{
274 bool ret;
275 ret = _internal_get_from_bb_int32 (bb, v);
276 if (ret && *v < 0)
277 ret = false;
278 return ret;
279}
280static bool
281_internal_get_from_bb_string_alloc (xmmsv_t *bb, char **buf,
282 unsigned int *len)
283{
284 char *str;
285 int32_t l;
286
287 if (!_internal_get_from_bb_int32_positive (bb, &l)) {
288 return false;
289 }
290
291 str = x_malloc (l + 1);
292 if (!str) {
293 return false;
294 }
295
296 if (!_internal_get_from_bb_data (bb, str, l)) {
297 free (str);
298 return false;
299 }
300
301 str[l] = '\0';
302
303 *buf = str;
304 *len = l;
305
306 return true;
307}
308
309static bool
310_internal_get_from_bb_bin_alloc (xmmsv_t *bb,
311 unsigned char **buf,
312 unsigned int *len)
313{
314 unsigned char *b;
315 int32_t l;
316
317 if (!_internal_get_from_bb_int32_positive (bb, &l)) {
318 return false;
319 }
320
321 b = x_malloc (l);
322 if (!b) {
323 return false;
324 }
325
326 if (!_internal_get_from_bb_data (bb, b, l)) {
327 free (b);
328 return false;
329 }
330
331 *buf = b;
332 *len = l;
333
334 return true;
335}
336
337static bool
338_internal_get_from_bb_collection_alloc (xmmsv_t *bb, xmmsv_coll_t **coll)
339{
340 int i;
341 int32_t type;
342 int32_t n_items;
343 int id;
344 int32_t *idlist = NULL;
345 char *key, *val;
346
347 /* Get the type and create the collection */
348 if (!_internal_get_from_bb_int32_positive (bb, &type)) {
349 return false;
350 }
351
352 *coll = xmmsv_coll_new (type);
353
354 /* Get the list of attributes */
355 if (!_internal_get_from_bb_int32_positive (bb, &n_items)) {
356 goto err;
357 }
358
359 for (i = 0; i < n_items; i++) {
360 unsigned int len;
361 if (!_internal_get_from_bb_string_alloc (bb, &key, &len)) {
362 goto err;
363 }
364 if (!_internal_get_from_bb_string_alloc (bb, &val, &len)) {
365 free (key);
366 goto err;
367 }
368
369 xmmsv_coll_attribute_set (*coll, key, val);
370 free (key);
371 free (val);
372 }
373
374 /* Get the idlist */
375 if (!_internal_get_from_bb_int32_positive (bb, &n_items)) {
376 goto err;
377 }
378
379 if (!(idlist = x_new (int32_t, n_items + 1))) {
380 goto err;
381 }
382
383 for (i = 0; i < n_items; i++) {
384 if (!_internal_get_from_bb_int32 (bb, &id)) {
385 goto err;
386 }
387
388 idlist[i] = id;
389 }
390
391 idlist[i] = 0;
392 xmmsv_coll_set_idlist (*coll, idlist);
393 free (idlist);
394 idlist = NULL;
395
396 /* Get the operands */
397 if (!_internal_get_from_bb_int32_positive (bb, &n_items)) {
398 goto err;
399 }
400
401 for (i = 0; i < n_items; i++) {
402 xmmsv_coll_t *operand;
403
404 if (!_internal_get_from_bb_int32_positive (bb, &type) ||
405 type != XMMSV_TYPE_COLL ||
406 !_internal_get_from_bb_collection_alloc (bb, &operand)) {
407 goto err;
408 }
409
410 xmmsv_coll_add_operand (*coll, operand);
411 xmmsv_coll_unref (operand);
412 }
413
414 return true;
415
416err:
417 if (idlist != NULL) {
418 free (idlist);
419 }
420
421 xmmsv_coll_unref (*coll);
422
423 return false;
424}
425
426
427static int
428xmmsc_deserialize_dict (xmmsv_t *bb, xmmsv_t **val)
429{
430 xmmsv_t *dict;
431 int32_t len;
432 unsigned int ignore;
433 char *key;
434
435 dict = xmmsv_new_dict ();
436
437 if (!_internal_get_from_bb_int32_positive (bb, &len)) {
438 goto err;
439 }
440
441 while (len--) {
442 xmmsv_t *v;
443
444 if (!_internal_get_from_bb_string_alloc (bb, &key, &ignore)) {
445 goto err;
446 }
447
448 if (!xmmsv_bitbuffer_deserialize_value (bb, &v)) {
449 free (key);
450 goto err;
451 }
452
453 xmmsv_dict_set (dict, key, v);
454 free (key);
455 xmmsv_unref (v);
456 }
457
458 *val = dict;
459
460 return true;
461
462err:
463 x_internal_error ("Message from server did not parse correctly!");
464 xmmsv_unref (dict);
465 return false;
466}
467
468static int
469xmmsc_deserialize_list (xmmsv_t *bb, xmmsv_t **val)
470{
471 xmmsv_t *list;
472 int32_t len;
473
474 list = xmmsv_new_list ();
475
476 if (!_internal_get_from_bb_int32_positive (bb, &len)) {
477 goto err;
478 }
479
480 while (len--) {
481 xmmsv_t *v;
483 xmmsv_list_append (list, v);
484 } else {
485 goto err;
486 }
487 xmmsv_unref (v);
488 }
489
490 *val = list;
491
492 return true;
493
494err:
495 x_internal_error ("Message from server did not parse correctly!");
496 xmmsv_unref (list);
497 return false;
498}
499
500static bool
501_internal_get_from_bb_value_of_type_alloc (xmmsv_t *bb, xmmsv_type_t type,
502 xmmsv_t **val)
503{
504 int32_t i;
505 uint32_t len;
506 char *s;
507 xmmsv_coll_t *c;
508 unsigned char *d;
509
510 switch (type) {
511 case XMMSV_TYPE_ERROR:
512 if (!_internal_get_from_bb_error_alloc (bb, &s, &len)) {
513 return false;
514 }
515 *val = xmmsv_new_error (s);
516 free (s);
517 break;
518 case XMMSV_TYPE_INT32:
519 if (!_internal_get_from_bb_int32 (bb, &i)) {
520 return false;
521 }
522 *val = xmmsv_new_int (i);
523 break;
525 if (!_internal_get_from_bb_string_alloc (bb, &s, &len)) {
526 return false;
527 }
528 *val = xmmsv_new_string (s);
529 free (s);
530 break;
531 case XMMSV_TYPE_DICT:
532 if (!xmmsc_deserialize_dict (bb, val)) {
533 return false;
534 }
535 break;
536
537 case XMMSV_TYPE_LIST :
538 if (!xmmsc_deserialize_list (bb, val)) {
539 return false;
540 }
541 break;
542
543 case XMMSV_TYPE_COLL:
544 if (!_internal_get_from_bb_collection_alloc (bb, &c)) {
545 return false;
546 }
547 *val = xmmsv_new_coll (c);
549 break;
550
551 case XMMSV_TYPE_BIN:
552 if (!_internal_get_from_bb_bin_alloc (bb, &d, &len)) {
553 return false;
554 }
555 *val = xmmsv_new_bin (d, len);
556 free (d);
557 break;
558
559 case XMMSV_TYPE_NONE:
560 *val = xmmsv_new_none ();
561 break;
562 default:
563 x_internal_error ("Got message of unknown type!");
564 return false;
565 }
566
567 return true;
568}
569
570
571
572int
574{
575 bool ret;
576 int32_t i;
577 const char *s;
578 xmmsv_coll_t *c;
579 const unsigned char *bc;
580 unsigned int bl;
581 xmmsv_type_t type;
582
583 type = xmmsv_get_type (v);
584 ret = _internal_put_on_bb_int32 (bb, type);
585 if (!ret)
586 return ret;
587
588 switch (type) {
589 case XMMSV_TYPE_ERROR:
590 if (!xmmsv_get_error (v, &s)) {
591 return false;
592 }
593 ret = _internal_put_on_bb_error (bb, s);
594 break;
595 case XMMSV_TYPE_INT32:
596 if (!xmmsv_get_int (v, &i)) {
597 return false;
598 }
599 ret = _internal_put_on_bb_int32 (bb, i);
600 break;
602 if (!xmmsv_get_string (v, &s)) {
603 return false;
604 }
605 ret = _internal_put_on_bb_string (bb, s);
606 break;
607 case XMMSV_TYPE_COLL:
608 if (!xmmsv_get_coll (v, &c)) {
609 return false;
610 }
611 ret = _internal_put_on_bb_collection (bb, c);
612 break;
613 case XMMSV_TYPE_BIN:
614 if (!xmmsv_get_bin (v, &bc, &bl)) {
615 return false;
616 }
617 ret = _internal_put_on_bb_bin (bb, bc, bl);
618 break;
619 case XMMSV_TYPE_LIST:
620 ret = _internal_put_on_bb_value_list (bb, v);
621 break;
622 case XMMSV_TYPE_DICT:
623 ret = _internal_put_on_bb_value_dict (bb, v);
624 break;
625
626 case XMMSV_TYPE_NONE:
627 break;
628 default:
629 x_internal_error ("Tried to serialize value of unsupported type");
630 return false;
631 }
632
633 return ret;
634}
635
636int
638{
639 int32_t type;
640
641 if (!_internal_get_from_bb_int32 (bb, &type)) {
642 return false;
643 }
644
645 return _internal_get_from_bb_value_of_type_alloc (bb, type, val);
646}
647
648
649xmmsv_t *
651{
652 xmmsv_t *bb, *res;
653
654 if (!v)
655 return NULL;
656
657 bb = xmmsv_bitbuffer_new ();
658
659 if (!xmmsv_bitbuffer_serialize_value (bb, v)) {
660 xmmsv_unref (bb);
661 return NULL;
662 }
663
664 /* this is internally in xmmsv implementation,
665 so we could just switch the type,
666 but thats for later */
668 xmmsv_unref (bb);
669 return res;
670}
671
672xmmsv_t *
674{
675 xmmsv_t *bb;
676 xmmsv_t *res;
677 const unsigned char *data;
678 uint32_t len;
679
680
681 if (!xmmsv_get_bin (v, &data, &len))
682 return NULL;
683
684
685 bb = xmmsv_bitbuffer_new_ro (data, len);
686
687 if (!xmmsv_bitbuffer_deserialize_value (bb, &res)) {
688 xmmsv_unref (bb);
689 return NULL;
690 }
691 xmmsv_unref (bb);
692 return res;
693}
int xmmsv_bitbuffer_get_bits(xmmsv_t *v, int bits, int *res)
Definition value.c:2524
xmmsv_t * xmmsv_bitbuffer_new(void)
Definition value.c:2511
int xmmsv_bitbuffer_put_bits_at(xmmsv_t *v, int bits, int d, int offset)
Definition value.c:2610
int xmmsv_bitbuffer_len(xmmsv_t *v)
Definition value.c:2671
int xmmsv_bitbuffer_deserialize_value(xmmsv_t *bb, xmmsv_t **val)
xmmsv_t * xmmsv_bitbuffer_new_ro(const unsigned char *v, int len)
Definition value.c:2499
int xmmsv_bitbuffer_pos(xmmsv_t *v)
Definition value.c:2653
int xmmsv_bitbuffer_put_data(xmmsv_t *v, const unsigned char *b, int len)
Definition value.c:2622
const unsigned char * xmmsv_bitbuffer_buffer(xmmsv_t *v)
Definition value.c:2677
int xmmsv_bitbuffer_get_data(xmmsv_t *v, unsigned char *b, int len)
Definition value.c:2553
int xmmsv_bitbuffer_serialize_value(xmmsv_t *bb, xmmsv_t *v)
int xmmsv_bitbuffer_put_bits(xmmsv_t *v, int bits, int d)
Definition value.c:2567
struct xmmsv_St * xmmsv_coll_idlist_get(xmmsv_coll_t *coll)
Return the list of ids stored in the collection.
Definition coll.c:429
xmmsv_coll_type_t xmmsv_coll_get_type(xmmsv_coll_t *coll)
Return the type of the collection.
Definition coll.c:367
struct xmmsv_St * xmmsv_coll_operands_get(xmmsv_coll_t *coll)
Definition coll.c:437
void xmmsv_coll_unref(xmmsv_coll_t *coll)
Decreases the references for the xmmsv_coll_t When the number of references reaches 0 it will be free...
Definition coll.c:140
size_t xmmsv_coll_idlist_get_size(xmmsv_coll_t *coll)
Get the size of the idlist.
Definition coll.c:352
void xmmsv_coll_attribute_set(xmmsv_coll_t *coll, const char *key, const char *value)
Set an attribute in the given collection.
Definition coll.c:460
void xmmsv_coll_set_idlist(xmmsv_coll_t *coll, int ids[])
Set the list of ids in the given collection.
Definition coll.c:161
struct xmmsv_St * xmmsv_coll_attributes_get(xmmsv_coll_t *coll)
Definition coll.c:445
xmmsv_coll_t * xmmsv_coll_new(xmmsv_coll_type_t type)
Allocate a new collection of the given type.
Definition coll.c:78
void xmmsv_coll_add_operand(xmmsv_coll_t *coll, xmmsv_coll_t *op)
Add the operand to the given collection.
Definition coll.c:195
void xmmsv_dict_iter_next(xmmsv_dict_iter_t *it)
Advance the iterator to the next pair in the dict.
Definition value.c:2009
struct xmmsv_dict_iter_St xmmsv_dict_iter_t
Definition xmmsv_dict.h:59
int xmmsv_dict_iter_pair(xmmsv_dict_iter_t *it, const char **key, xmmsv_t **val)
Get the key-element pair currently pointed at by the iterator.
Definition value.c:1948
int xmmsv_get_dict_iter(const xmmsv_t *val, xmmsv_dict_iter_t **it)
Retrieves a dict iterator from a dict xmmsv_t.
Definition value.c:955
int xmmsv_dict_foreach(xmmsv_t *dictv, xmmsv_dict_foreach_func func, void *user_data)
Apply a function to each key-element pair in the list.
Definition value.c:1853
int xmmsv_dict_iter_valid(xmmsv_dict_iter_t *it)
Check whether the iterator is valid and points to a valid pair.
Definition value.c:1983
int xmmsv_dict_set(xmmsv_t *dictv, const char *key, xmmsv_t *val)
Insert an element under the given key in the dict xmmsv_t.
Definition value.c:1752
xmmsv_t * xmmsv_new_dict(void)
Allocates a new dict xmmsv_t.
Definition value.c:268
int xmmsv_get_list_iter(const xmmsv_t *val, xmmsv_list_iter_t **it)
Retrieves a list iterator from a list xmmsv_t.
Definition value.c:926
void xmmsv_list_iter_next(xmmsv_list_iter_t *it)
Advance the iterator to the next element in the list.
Definition value.c:1553
struct xmmsv_list_iter_St xmmsv_list_iter_t
Definition xmmsv_list.h:69
int xmmsv_list_iter_entry(xmmsv_list_iter_t *it, xmmsv_t **val)
Get the element currently pointed at by the iterator.
Definition value.c:1495
void xmmsv_list_iter_first(xmmsv_list_iter_t *it)
Rewind the iterator to the start of the list.
Definition value.c:1523
void xmmsv_list_iter_explicit_destroy(xmmsv_list_iter_t *it)
Explicitly free list iterator.
Definition value.c:1478
int xmmsv_list_iter_valid(xmmsv_list_iter_t *it)
Check whether the iterator is valid and points to a valid element.
Definition value.c:1512
int xmmsv_list_iter_entry_int(xmmsv_list_iter_t *it, int32_t *val)
xmmsv_t * xmmsv_new_list(void)
Allocates a new list xmmsv_t.
Definition value.c:250
int xmmsv_list_get_size(xmmsv_t *listv)
Return the size of the list.
Definition value.c:1403
int xmmsv_list_append(xmmsv_t *listv, xmmsv_t *val)
Append an element to the end of the list xmmsv_t.
Definition value.c:1340
xmmsv_t * xmmsv_serialize(xmmsv_t *v)
xmmsv_t * xmmsv_deserialize(xmmsv_t *v)
void xmmsv_unref(xmmsv_t *val)
Decreases the references for the xmmsv_t When the number of references reaches 0 it will be freed.
Definition value.c:303
xmmsv_t * xmmsv_new_none(void)
Allocates a new empty xmmsv_t.
Definition value.c:129
int xmmsv_get_coll(const xmmsv_t *val, xmmsv_coll_t **coll)
Retrieves a collection from the value.
Definition value.c:883
xmmsv_t * xmmsv_new_string(const char *s)
Allocates a new string xmmsv_t.
Definition value.c:180
int xmmsv_get_string(const xmmsv_t *val, const char **r)
Retrieves a string from the value.
Definition value.c:863
struct xmmsv_St xmmsv_t
xmmsv_t * xmmsv_new_coll(xmmsv_coll_t *coll)
Allocates a new collection xmmsv_t.
Definition value.c:202
int xmmsv_get_int(const xmmsv_t *val, int32_t *r)
Retrieves a signed integer from the value.
Definition value.c:823
xmmsv_type_t
int xmmsv_get_error(const xmmsv_t *val, const char **r)
Retrieves an error string describing the server error from the value.
Definition value.c:804
xmmsv_type_t xmmsv_get_type(const xmmsv_t *val)
Get the type of the value.
Definition value.c:392
xmmsv_t * xmmsv_new_int(int32_t i)
Allocates a new integer xmmsv_t.
Definition value.c:161
xmmsv_t * xmmsv_new_bin(const unsigned char *data, unsigned int len)
Allocates a new binary data xmmsv_t.
Definition value.c:225
xmmsv_t * xmmsv_new_error(const char *errstr)
Allocates a new error xmmsv_t.
Definition value.c:143
int xmmsv_get_bin(const xmmsv_t *val, const unsigned char **r, unsigned int *rlen)
Retrieves binary data from the value.
Definition value.c:904
@ XMMSV_TYPE_NONE
@ XMMSV_TYPE_DICT
@ XMMSV_TYPE_COLL
@ XMMSV_TYPE_BIN
@ XMMSV_TYPE_ERROR
@ XMMSV_TYPE_INT32
@ XMMSV_TYPE_STRING
@ XMMSV_TYPE_LIST
@ XMMS_COLLECTION_TYPE_REFERENCE
#define x_new(type, num)
Definition xmmsc_util.h:17
#define x_malloc(size)
Definition xmmsc_util.h:19
#define x_return_if_fail(expr)
Definition xmmsc_util.h:12
struct xmmsv_coll_St xmmsv_coll_t
Definition xmmsv_coll.h:28