static bool
_internal_put_on_bb_value_dict (xmmsv_t *bb, xmmsv_t *v)
{
xmmsv_dict_iter_t *it;
const char *key;
xmmsv_t *entry;
uint32_t ret, offset, count;
if (!xmmsv_get_dict_iter (v, &it)) {
return false;
}
/* store a dummy value, store the real count once it's known */
offset = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, 0);
count = 0;
while (xmmsv_dict_iter_valid (it)) {
xmmsv_dict_iter_pair (it, &key, &entry);
ret = _internal_put_on_bb_string (bb, key);
ret = xmmsv_bitbuffer_serialize_value (bb, entry);
xmmsv_dict_iter_next (it);
count++;
}
/* overwrite with real size */
xmmsv_bitbuffer_put_bits_at (bb, 32, count, offset);
return ret;
}
static bool
_internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v)
{
xmmsv_list_iter_t *it;
xmmsv_t *entry;
uint32_t offset, count;
bool ret = true;
if (!xmmsv_get_list_iter (v, &it)) {
return false;
}
/* store a dummy value, store the real count once it's known */
offset = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, 0);
count = 0;
while (xmmsv_list_iter_valid (it)) {
xmmsv_list_iter_entry (it, &entry);
ret = xmmsv_bitbuffer_serialize_value (bb, entry);
xmmsv_list_iter_next (it);
count++;
}
/* overwrite with real size */
xmmsv_bitbuffer_put_bits_at (bb, 32, count, offset);
return ret;
}
uint32_t
xmms_ipc_msg_put_value (xmms_ipc_msg_t *msg, xmmsv_t *v)
{
if (!xmmsv_bitbuffer_serialize_value (msg->bb, v))
return false;
xmms_ipc_msg_update_length (msg->bb);
return xmmsv_bitbuffer_pos (msg->bb);
}
/**
* Return a new value object which is a deep copy of the input value
*
* @param val #xmmsv_t to copy.
* @return 1 the address to the new copy of the value.
*/
xmmsv_t *
xmmsv_copy (xmmsv_t *val)
{
xmmsv_t *cur_val = NULL;
xmmsv_type_t type;
int64_t i;
const char *s;
float f;
x_return_val_if_fail (val, 0);
type = xmmsv_get_type (val);
switch (type) {
case XMMSV_TYPE_DICT:
cur_val = duplicate_dict_value (val);
break;
case XMMSV_TYPE_LIST:
cur_val = duplicate_list_value (val);
break;
case XMMSV_TYPE_INT64:
xmmsv_get_int (val, &i);
cur_val = xmmsv_new_int (i);
break;
case XMMSV_TYPE_FLOAT:
xmmsv_get_float (val, &f);
cur_val = xmmsv_new_float (f);
break;
case XMMSV_TYPE_STRING:
xmmsv_get_string (val, &s);
cur_val = xmmsv_new_string (s);
break;
case XMMSV_TYPE_ERROR:
xmmsv_get_error (val, &s);
cur_val = xmmsv_new_error (s);
break;
case XMMSV_TYPE_COLL:
cur_val = duplicate_coll_value (val);
break;
case XMMSV_TYPE_BIN:
cur_val = xmmsv_new_bin (val->value.bin.data, val->value.bin.len);
break;
case XMMSV_TYPE_BITBUFFER:
cur_val = xmmsv_new_bitbuffer ();
xmmsv_bitbuffer_put_data (cur_val, val->value.bit.buf, val->value.bit.len / 8);
xmmsv_bitbuffer_goto (cur_val, xmmsv_bitbuffer_pos (val));
break;
default:
cur_val = xmmsv_new_none ();
break;
}
assert (cur_val);
return cur_val;
}
uint32_t
xmms_ipc_msg_get_object (const xmms_ipc_msg_t *msg)
{
int64_t obj;
int32_t p;
x_return_val_if_fail (msg, 0);
p = xmmsv_bitbuffer_pos (msg->bb);
xmmsv_bitbuffer_goto (msg->bb, 0);
xmmsv_bitbuffer_get_bits (msg->bb, 32, &obj);
xmmsv_bitbuffer_goto (msg->bb, p);
return obj;
}
static uint32_t
xmms_ipc_msg_get_length (const xmms_ipc_msg_t *msg)
{
int64_t len;
int32_t p;
x_return_val_if_fail (msg, 0);
p = xmmsv_bitbuffer_pos (msg->bb);
xmmsv_bitbuffer_goto (msg->bb, 12*8);
xmmsv_bitbuffer_get_bits (msg->bb, 32, &len);
xmmsv_bitbuffer_goto (msg->bb, p);
return len;
}
uint32_t
xmms_ipc_msg_get_cookie (const xmms_ipc_msg_t *msg)
{
int64_t cookie;
int32_t p;
x_return_val_if_fail (msg, 0);
p = xmmsv_bitbuffer_pos (msg->bb);
xmmsv_bitbuffer_goto (msg->bb, 8 * 8);
xmmsv_bitbuffer_get_bits (msg->bb, 32, &cookie);
xmmsv_bitbuffer_goto (msg->bb, p);
return cookie;
}
uint32_t
xmms_ipc_msg_get_cmd (const xmms_ipc_msg_t *msg)
{
int64_t cmd;
int32_t p;
x_return_val_if_fail (msg, 0);
p = xmmsv_bitbuffer_pos (msg->bb);
xmmsv_bitbuffer_goto (msg->bb, 4 * 8);
xmmsv_bitbuffer_get_bits (msg->bb, 32, &cmd);
xmmsv_bitbuffer_goto (msg->bb, p);
return cmd;
}
static bool
_internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
{
xmmsv_list_iter_t *it;
xmmsv_t *v, *attrs;
int n;
uint32_t ret;
int32_t entry;
xmmsv_coll_t *op;
if (!bb || !coll) {
return false;
}
/* push type */
if (!xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_get_type (coll)))
return false;
/* attribute counter and values */
attrs = xmmsv_coll_attributes_get (coll);
n = 0;
xmmsv_dict_foreach (attrs, _internal_put_on_bb_count_coll_attr, &n);
if (!xmmsv_bitbuffer_put_bits (bb, 32, n))
return false;
/* needs error checking! */
xmmsv_dict_foreach (attrs, _internal_put_on_bb_append_coll_attr, bb);
attrs = NULL; /* no unref needed. */
/* idlist counter and content */
xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_idlist_get_size (coll));
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
if (!xmmsv_list_iter_entry_int (it, &entry)) {
x_api_error ("Non integer in idlist", 0);
}
xmmsv_bitbuffer_put_bits (bb, 32, entry);
}
xmmsv_list_iter_explicit_destroy (it);
/* operands counter and objects */
n = 0;
if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) {
n = xmmsv_list_get_size (xmmsv_coll_operands_get (coll));
}
ret = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, n);
if (n > 0) {
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &it);
while (xmmsv_list_iter_entry (it, &v)) {
if (!xmmsv_get_coll (v, &op)) {
x_api_error ("Non collection operand", 0);
}
_internal_put_on_bb_int32 (bb, XMMSV_TYPE_COLL);
ret = _internal_put_on_bb_collection (bb, op);
xmmsv_list_iter_next (it);
}
}
return ret;
}
