static VALUE
float_get (xmmsv_t *val)
{
float id = 0;
if (!xmmsv_get_float (val, &id))
rb_raise (eValueError, "cannot retrieve value");
return rb_float_new((double) id);
}
/**
* 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;
}
/**
* This function will make a pretty string about the information in
* xmmsv dict.
*
* @param target A allocated char *
* @param len Length of target
* @param fmt A format string to use. You can insert items from the dict by
* using specialformat "${field}".
* @param val The #xmmsv_t that contains the dict.
*
* @returns The number of chars written to target
*/
int
xmmsv_dict_format (char *target, int len, const char *fmt, xmmsv_t *val)
{
const char *pos;
if (!target) {
return 0;
}
if (!fmt) {
return 0;
}
memset (target, 0, len);
pos = fmt;
while (strlen (target) + 1 < len) {
char *next_key, *key, *end;
int keylen;
xmmsv_dict_iter_t *it;
xmmsv_t *v;
next_key = strstr (pos, "${");
if (!next_key) {
strncat (target, pos, len - strlen (target) - 1);
break;
}
strncat (target, pos, MIN (next_key - pos, len - strlen (target) - 1));
keylen = strcspn (next_key + 2, "}");
key = malloc (keylen + 1);
if (!key) {
fprintf (stderr, "Unable to allocate %u bytes of memory, OOM?", keylen);
break;
}
memset (key, 0, keylen + 1);
strncpy (key, next_key + 2, keylen);
xmmsv_get_dict_iter (val, &it);
if (strcmp (key, "seconds") == 0) {
int64_t duration;
if (xmmsv_dict_iter_find (it, "duration")) {
xmmsv_dict_iter_pair (it, NULL, &v);
xmmsv_get_int (v, &duration);
} else {
duration = 0;
}
if (!duration) {
strncat (target, "00", len - strlen (target) - 1);
} else {
char seconds[21];
/* rounding */
duration += 500;
snprintf (seconds, sizeof (seconds), "%02" PRId64, (duration/1000)%60);
strncat (target, seconds, len - strlen (target) - 1);
}
} else if (strcmp (key, "minutes") == 0) {
int64_t duration;
if (xmmsv_dict_iter_find (it, "duration")) {
xmmsv_dict_iter_pair (it, NULL, &v);
xmmsv_get_int (v, &duration);
} else {
duration = 0;
}
if (!duration) {
strncat (target, "00", len - strlen (target) - 1);
} else {
char minutes[21];
/* rounding */
duration += 500;
snprintf (minutes, sizeof (minutes), "%02" PRId64, duration/60000);
strncat (target, minutes, len - strlen (target) - 1);
}
} else {
const char *result = NULL;
char tmp[21];
if (xmmsv_dict_iter_find (it, key)) {
xmmsv_dict_iter_pair (it, NULL, &v);
xmmsv_type_t type = xmmsv_get_type (v);
if (type == XMMSV_TYPE_STRING) {
xmmsv_get_string (v, &result);
} else if (type == XMMSV_TYPE_INT64) {
int64_t i;
xmmsv_get_int (v, &i);
snprintf (tmp, 21, "%" PRId64, i);
result = tmp;
} else if (type == XMMSV_TYPE_FLOAT) {
float f;
xmmsv_get_float (v, &f);
snprintf (tmp, 12, "%.6f", f);
result = tmp;
}
}
if (result)
strncat (target, result, len - strlen (target) - 1);
}
free (key);
end = strchr (next_key, '}');
if (!end) {
break;
}
pos = end + 1;
}
return strlen (target);
}
