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 
24 static bool _internal_put_on_bb_bin (xmmsv_t *bb, const unsigned char *data, unsigned int len);
25 static bool _internal_put_on_bb_error (xmmsv_t *bb, const char *errmsg);
26 static bool _internal_put_on_bb_int32 (xmmsv_t *bb, int32_t v);
27 static bool _internal_put_on_bb_string (xmmsv_t *bb, const char *str);
28 static bool _internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll);
29 static bool _internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v);
30 static bool _internal_put_on_bb_value_dict (xmmsv_t *bb, xmmsv_t *v);
31 
32 static bool _internal_get_from_bb_error_alloc (xmmsv_t *bb, char **buf, unsigned int *len);
33 static bool _internal_get_from_bb_int32 (xmmsv_t *bb, int32_t *v);
34 static bool _internal_get_from_bb_int32_positive (xmmsv_t *bb, int32_t *v);
35 static bool _internal_get_from_bb_string_alloc (xmmsv_t *bb, char **buf, unsigned int *len);
36 static bool _internal_get_from_bb_collection_alloc (xmmsv_t *bb, xmmsv_coll_t **coll);
37 static bool _internal_get_from_bb_bin_alloc (xmmsv_t *bb, unsigned char **buf, unsigned int *len);
38 
39 static bool _internal_get_from_bb_value_of_type_alloc (xmmsv_t *bb, xmmsv_type_t type, xmmsv_t **val);
40 
41 
42 static 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);
50  x_return_if_fail (r);
51 
52  _internal_put_on_bb_string (bb, key);
53  _internal_put_on_bb_string (bb, s);
54 }
55 
56 static 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 
63 static 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 
74 static 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 
91 static 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 
97 static 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 
114 static bool
115 _internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
116 {
117  xmmsv_list_iter_t *it;
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);
151  xmmsv_list_iter_next (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 
187 static bool
188 _internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v)
189 {
190  xmmsv_list_iter_t *it;
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 
217 static bool
218 _internal_put_on_bb_value_dict (xmmsv_t *bb, xmmsv_t *v)
219 {
220  xmmsv_dict_iter_t *it;
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 
248 static 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 
257 static 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 
265 static 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 
271 static 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 }
280 static 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 
309 static 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 
337 static 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 
416 err:
417  if (idlist != NULL) {
418  free (idlist);
419  }
420 
421  xmmsv_coll_unref (*coll);
422 
423  return false;
424 }
425 
426 
427 static int
428 xmmsc_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 
462 err:
463  x_internal_error ("Message from server did not parse correctly!");
464  xmmsv_unref (dict);
465  return false;
466 }
467 
468 static int
469 xmmsc_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;
482  if (xmmsv_bitbuffer_deserialize_value (bb, &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 
494 err:
495  x_internal_error ("Message from server did not parse correctly!");
496  xmmsv_unref (list);
497  return false;
498 }
499 
500 static 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;
524  case XMMSV_TYPE_STRING:
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);
548  xmmsv_coll_unref (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 
572 int
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;
601  case XMMSV_TYPE_STRING:
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 
636 int
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 
649 xmmsv_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 
672 xmmsv_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 }
void xmmsv_list_iter_first(xmmsv_list_iter_t *it)
Rewind the iterator to the start of the list.
Definition: value.c:1523
xmmsv_t * xmmsv_bitbuffer_new_ro(const unsigned char *v, int len)
Definition: value.c:2499
struct xmmsv_list_iter_St xmmsv_list_iter_t
Definition: xmmsv_list.h:69
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
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
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_new_error(const char *errstr)
Allocates a new error xmmsv_t.
Definition: value.c:143
struct xmmsv_St xmmsv_t
Definition: xmmsv_general.h:48
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
xmmsv_t * xmmsv_new_none(void)
Allocates a new empty xmmsv_t.
Definition: value.c:129
#define x_malloc(size)
Definition: xmmsc_util.h:19
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
xmmsv_t * xmmsv_new_string(const char *s)
Allocates a new string xmmsv_t.
Definition: value.c:180
xmmsv_t * xmmsv_deserialize(xmmsv_t *v)
int xmmsv_get_int(const xmmsv_t *val, int32_t *r)
Retrieves a signed integer from the value.
Definition: value.c:823
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
int xmmsv_bitbuffer_get_data(xmmsv_t *v, unsigned char *b, int len)
Definition: value.c:2553
void xmmsv_dict_iter_next(xmmsv_dict_iter_t *it)
Advance the iterator to the next pair in the dict.
Definition: value.c:2009
xmmsv_t * xmmsv_new_dict(void)
Allocates a new dict xmmsv_t.
Definition: value.c:268
struct xmmsv_St * xmmsv_coll_operands_get(xmmsv_coll_t *coll)
Definition: coll.c:437
size_t xmmsv_coll_idlist_get_size(xmmsv_coll_t *coll)
Get the size of the idlist.
Definition: coll.c:352
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
struct xmmsv_St * xmmsv_coll_idlist_get(xmmsv_coll_t *coll)
Return the list of ids stored in the collection.
Definition: coll.c:429
int xmmsv_bitbuffer_pos(xmmsv_t *v)
Definition: value.c:2653
void xmmsv_list_iter_next(xmmsv_list_iter_t *it)
Advance the iterator to the next element in the list.
Definition: value.c:1553
const unsigned char * xmmsv_bitbuffer_buffer(xmmsv_t *v)
Definition: value.c:2677
xmmsv_t * xmmsv_new_list(void)
Allocates a new list xmmsv_t.
Definition: value.c:250
void xmmsv_list_iter_explicit_destroy(xmmsv_list_iter_t *it)
Explicitly free list iterator.
Definition: value.c:1478
struct xmmsv_coll_St xmmsv_coll_t
Definition: xmmsv_coll.h:28
int xmmsv_bitbuffer_put_bits(xmmsv_t *v, int bits, int d)
Definition: value.c:2567
#define x_new(type, num)
Definition: xmmsc_util.h:17
int xmmsv_bitbuffer_put_bits_at(xmmsv_t *v, int bits, int d, int offset)
Definition: value.c:2610
xmmsv_t * xmmsv_serialize(xmmsv_t *v)
int xmmsv_bitbuffer_deserialize_value(xmmsv_t *bb, xmmsv_t **val)
xmmsv_t * xmmsv_new_coll(xmmsv_coll_t *coll)
Allocates a new collection xmmsv_t.
Definition: value.c:202
xmmsv_coll_t * xmmsv_coll_new(xmmsv_coll_type_t type)
Allocate a new collection of the given type.
Definition: coll.c:78
xmmsv_type_t
Definition: xmmsv_general.h:35
int xmmsv_bitbuffer_len(xmmsv_t *v)
Definition: value.c:2671
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
struct xmmsv_St * xmmsv_coll_attributes_get(xmmsv_coll_t *coll)
Definition: coll.c:445
void xmmsv_coll_add_operand(xmmsv_coll_t *coll, xmmsv_coll_t *op)
Add the operand to the given collection.
Definition: coll.c:195
int xmmsv_list_get_size(xmmsv_t *listv)
Return the size of the list.
Definition: value.c:1403
void xmmsv_coll_set_idlist(xmmsv_coll_t *coll, int ids[])
Set the list of ids in the given collection.
Definition: coll.c:161
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
int xmmsv_bitbuffer_serialize_value(xmmsv_t *bb, xmmsv_t *v)
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
int xmmsv_bitbuffer_put_data(xmmsv_t *v, const unsigned char *b, int len)
Definition: value.c:2622
#define x_return_if_fail(expr)
Definition: xmmsc_util.h:12
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_get_string(const xmmsv_t *val, const char **r)
Retrieves a string from the value.
Definition: value.c:863
int xmmsv_bitbuffer_get_bits(xmmsv_t *v, int bits, int *res)
Definition: value.c:2524
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
struct xmmsv_dict_iter_St xmmsv_dict_iter_t
Definition: xmmsv_dict.h:59
int xmmsv_list_iter_entry_int(xmmsv_list_iter_t *it, int32_t *val)
xmmsv_t * xmmsv_new_bin(const unsigned char *data, unsigned int len)
Allocates a new binary data xmmsv_t.
Definition: value.c:225
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
xmmsv_coll_type_t xmmsv_coll_get_type(xmmsv_coll_t *coll)
Return the type of the collection.
Definition: coll.c:367
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_bitbuffer_new(void)
Definition: value.c:2511
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