libgupnp/gvalue-util.c

   1 /*
   2  * Copyright (C) 2007 OpenedHand Ltd.
   3  *
   4  * Author: Jorn Baayen <jorn@openedhand.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 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  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include "gvalue-util.h"
  26 #include "xml-util.h"
  27 #include "gupnp-types.h"
  28
  29 gboolean
  30 gvalue_util_set_value_from_string (GValue     *value,
  31                                    const char *str)
  32 {
  33         GValue tmp_value = {0, };
  34         int i;
  35
  36         g_return_val_if_fail (str != NULL, FALSE);
  37
  38         switch (G_VALUE_TYPE (value)) {
  39         case G_TYPE_STRING:
  40                 g_value_set_string (value, str);
  41
  42                 break;
  43
  44         case G_TYPE_CHAR:
  45                 g_value_set_char (value, *str);
  46
  47                 break;
  48
  49         case G_TYPE_UCHAR:
  50                 g_value_set_uchar (value, *str);
  51
  52                 break;
  53
  54         case G_TYPE_INT:
  55                 g_value_set_int (value, strtol (str, NULL, 10));
  56
  57                 break;
  58
  59         case G_TYPE_UINT:
  60                 g_value_set_uint (value, strtoul (str, NULL, 10));
  61
  62                 break;
  63
  64         case G_TYPE_INT64:
  65                 g_value_set_int64 (value, g_ascii_strtoll (str, NULL, 10));
  66
  67                 break;
  68
  69         case G_TYPE_UINT64:
  70                 g_value_set_uint64 (value, g_ascii_strtoull (str, NULL, 10));
  71
  72                 break;
  73
  74         case G_TYPE_LONG:
  75                 g_value_set_long (value, strtol (str, NULL, 10));
  76
  77                 break;
  78
  79         case G_TYPE_ULONG:
  80                 g_value_set_ulong (value, strtoul (str, NULL, 10));
  81
  82                 break;
  83
  84         case G_TYPE_FLOAT:
  85                 g_value_set_float (value, g_ascii_strtod (str, NULL));
  86
  87                 break;
  88
  89         case G_TYPE_DOUBLE:
  90                 g_value_set_double (value, g_ascii_strtod (str, NULL));
  91
  92                 break;
  93
  94         case G_TYPE_BOOLEAN:
  95                 if (g_ascii_strcasecmp (str, "true") == 0 ||
  96                     g_ascii_strcasecmp (str, "yes") == 0)
  97                         g_value_set_boolean (value, TRUE);
  98                 else if (g_ascii_strcasecmp (str, "false") == 0 ||
  99                          g_ascii_strcasecmp (str, "no") == 0)
 100                         g_value_set_boolean (value, FALSE);
 101                 else {
 102                         i = atoi (str);
 103                         g_value_set_boolean (value, i ? TRUE : FALSE);
 104                 }
 105
 106                 break;
 107
 108         default:
 109                 /* Try to convert */
 110                 if (g_value_type_transformable (G_TYPE_STRING,
 111                                                 G_VALUE_TYPE (value))) {
 112                         g_value_init (&tmp_value, G_TYPE_STRING);
 113                         g_value_set_static_string (&tmp_value, str);
 114
 115                         g_value_transform (&tmp_value, value);
 116
 117                         g_value_unset (&tmp_value);
 118
 119                 } else if (g_value_type_transformable (G_TYPE_INT,
 120                                                        G_VALUE_TYPE (value))) {
 121                         i = atoi (str);
 122
 123                         g_value_init (&tmp_value, G_TYPE_INT);
 124                         g_value_set_int (&tmp_value, i);
 125
 126                         g_value_transform (&tmp_value, value);
 127
 128                         g_value_unset (&tmp_value);
 129
 130                 } else {
 131                         g_warning ("Failed to transform integer "
 132                                    "value to type %s",
 133                                    G_VALUE_TYPE_NAME (value));
 134
 135                         return FALSE;
 136                 }
 137
 138                 break;
 139         }
 140
 141         return TRUE;
 142 }
 143
 144 gboolean
 145 gvalue_util_set_value_from_xml_node (GValue  *value,
 146                                      xmlNode *node)
 147 {
 148         xmlChar *str;
 149         int ret;
 150
 151         str = xmlNodeGetContent (node);
 152
 153         ret = gvalue_util_set_value_from_string (value, (const char *) str);
 154
 155         xmlFree (str);
 156
 157         return ret;
 158 }
 159
 160 gboolean
 161 gvalue_util_value_append_to_xml_string (const GValue *value,
 162                                         GString      *str)
 163 {
 164         GValue transformed_value = {0, };
 165         const char *tmp;
 166         char buf[G_ASCII_DTOSTR_BUF_SIZE];
 167
 168         switch (G_VALUE_TYPE (value)) {
 169         case G_TYPE_STRING:
 170                 /* Escape and append */
 171                 tmp = g_value_get_string (value);
 172                 if (tmp != NULL)
 173                         xml_util_add_content (str, tmp);
 174
 175                 return TRUE;
 176
 177         case G_TYPE_CHAR:
 178                 g_string_append_c (str, g_value_get_char (value));
 179
 180                 return TRUE;
 181
 182         case G_TYPE_UCHAR:
 183                 g_string_append_c (str, g_value_get_uchar (value));
 184
 185                 return TRUE;
 186
 187         case G_TYPE_INT:
 188                 g_string_append_printf (str, "%d", g_value_get_int (value));
 189
 190                 return TRUE;
 191
 192         case G_TYPE_UINT:
 193                 g_string_append_printf (str, "%u", g_value_get_uint (value));
 194
 195                 return TRUE;
 196
 197         case G_TYPE_INT64:
 198                 g_string_append_printf (str, "%"G_GINT64_FORMAT,
 199                                         g_value_get_int64 (value));
 200
 201                 return TRUE;
 202
 203         case G_TYPE_UINT64:
 204                 g_string_append_printf (str, "%"G_GUINT64_FORMAT,
 205                                         g_value_get_uint64 (value));
 206
 207                 return TRUE;
 208
 209         case G_TYPE_LONG:
 210                 g_string_append_printf (str, "%ld", g_value_get_long (value));
 211
 212                 return TRUE;
 213
 214         case G_TYPE_ULONG:
 215                 g_string_append_printf (str, "%lu", g_value_get_ulong (value));
 216
 217                 return TRUE;
 218
 219         case G_TYPE_FLOAT:
 220                 g_string_append (str,
 221                                  g_ascii_dtostr (buf,
 222                                                  sizeof (buf),
 223                                                  g_value_get_float (value)));
 224
 225                 return TRUE;
 226
 227         case G_TYPE_DOUBLE:
 228                 g_string_append (str,
 229                                  g_ascii_dtostr (buf,
 230                                                  sizeof (buf),
 231                                                  g_value_get_double (value)));
 232
 233                 return TRUE;
 234
 235         case G_TYPE_BOOLEAN:
 236                 /* We don't want to convert to "TRUE"/"FALSE" */
 237                 if (g_value_get_boolean (value))
 238                         g_string_append_c (str, '1');
 239                 else
 240                         g_string_append_c (str, '0');
 241
 242                 return TRUE;
 243
 244         default:
 245                 /* Try to convert */
 246                 if (g_value_type_transformable (G_VALUE_TYPE (value),
 247                                                 G_TYPE_STRING)) {
 248                         g_value_init (&transformed_value, G_TYPE_STRING);
 249
 250                         g_value_transform (value, &transformed_value);
 251
 252                         tmp = g_value_get_string (&transformed_value);
 253                         if (tmp != NULL)
 254                                 xml_util_add_content (str, tmp);
 255
 256                         g_value_unset (&transformed_value);
 257
 258                         return TRUE;
 259                 } else {
 260                         g_warning ("Failed to transform value of type %s "
 261                                    "to a string", G_VALUE_TYPE_NAME (value));
 262
 263                         return FALSE;
 264                 }
 265         }
 266 }