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., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, 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 #if GLIB_CHECK_VERSION(2,32,0)
  46                 g_value_set_schar (value, *str);
  47 #else
  48                 g_value_set_char (value, *str);
  49 #endif
  50
  51                 break;
  52
  53         case G_TYPE_UCHAR:
  54                 g_value_set_uchar (value, *str);
  55
  56                 break;
  57
  58         case G_TYPE_INT:
  59                 g_value_set_int (value, strtol (str, NULL, 10));
  60
  61                 break;
  62
  63         case G_TYPE_UINT:
  64                 g_value_set_uint (value, strtoul (str, NULL, 10));
  65
  66                 break;
  67
  68         case G_TYPE_INT64:
  69                 g_value_set_int64 (value, g_ascii_strtoll (str, NULL, 10));
  70
  71                 break;
  72
  73         case G_TYPE_UINT64:
  74                 g_value_set_uint64 (value, g_ascii_strtoull (str, NULL, 10));
  75
  76                 break;
  77
  78         case G_TYPE_LONG:
  79                 g_value_set_long (value, strtol (str, NULL, 10));
  80
  81                 break;
  82
  83         case G_TYPE_ULONG:
  84                 g_value_set_ulong (value, strtoul (str, NULL, 10));
  85
  86                 break;
  87
  88         case G_TYPE_FLOAT:
  89                 g_value_set_float (value, g_ascii_strtod (str, NULL));
  90
  91                 break;
  92
  93         case G_TYPE_DOUBLE:
  94                 g_value_set_double (value, g_ascii_strtod (str, NULL));
  95
  96                 break;
  97
  98         case G_TYPE_BOOLEAN:
  99                 if (g_ascii_strcasecmp (str, "true") == 0 ||
 100                     g_ascii_strcasecmp (str, "yes") == 0)
 101                         g_value_set_boolean (value, TRUE);
 102                 else if (g_ascii_strcasecmp (str, "false") == 0 ||
 103                          g_ascii_strcasecmp (str, "no") == 0)
 104                         g_value_set_boolean (value, FALSE);
 105                 else {
 106                         i = atoi (str);
 107                         g_value_set_boolean (value, i ? TRUE : FALSE);
 108                 }
 109
 110                 break;
 111
 112         default:
 113                 /* Try to convert */
 114                 if (g_value_type_transformable (G_TYPE_STRING,
 115                                                 G_VALUE_TYPE (value))) {
 116                         g_value_init (&tmp_value, G_TYPE_STRING);
 117                         g_value_set_static_string (&tmp_value, str);
 118
 119                         g_value_transform (&tmp_value, value);
 120
 121                         g_value_unset (&tmp_value);
 122
 123                 } else if (g_value_type_transformable (G_TYPE_INT,
 124                                                        G_VALUE_TYPE (value))) {
 125                         i = atoi (str);
 126
 127                         g_value_init (&tmp_value, G_TYPE_INT);
 128                         g_value_set_int (&tmp_value, i);
 129
 130                         g_value_transform (&tmp_value, value);
 131
 132                         g_value_unset (&tmp_value);
 133
 134                 } else {
 135                         g_warning ("Failed to transform integer "
 136                                    "value to type %s",
 137                                    G_VALUE_TYPE_NAME (value));
 138
 139                         return FALSE;
 140                 }
 141
 142                 break;
 143         }
 144
 145         return TRUE;
 146 }
 147
 148 gboolean
 149 gvalue_util_set_value_from_xml_node (GValue  *value,
 150                                      xmlNode *node)
 151 {
 152         xmlChar *str;
 153         int ret;
 154
 155         str = xmlNodeGetContent (node);
 156
 157         ret = gvalue_util_set_value_from_string (value, (const char *) str);
 158
 159         xmlFree (str);
 160
 161         return ret;
 162 }
 163
 164 gboolean
 165 gvalue_util_value_append_to_xml_string (const GValue *value,
 166                                         GString      *str)
 167 {
 168         GValue transformed_value = {0, };
 169         const char *tmp;
 170         char buf[G_ASCII_DTOSTR_BUF_SIZE];
 171
 172         switch (G_VALUE_TYPE (value)) {
 173         case G_TYPE_STRING:
 174                 /* Escape and append */
 175                 tmp = g_value_get_string (value);
 176                 if (tmp != NULL)
 177                         xml_util_add_content (str, tmp);
 178
 179                 return TRUE;
 180
 181         case G_TYPE_CHAR:
 182 #if GLIB_CHECK_VERSION(2,32,0)
 183                 g_string_append_c (str, g_value_get_schar (value));
 184 #else
 185                 g_string_append_c (str, g_value_get_char (value));
 186 #endif
 187
 188                 return TRUE;
 189
 190         case G_TYPE_UCHAR:
 191                 g_string_append_c (str, g_value_get_uchar (value));
 192
 193                 return TRUE;
 194
 195         case G_TYPE_INT:
 196                 g_string_append_printf (str, "%d", g_value_get_int (value));
 197
 198                 return TRUE;
 199
 200         case G_TYPE_UINT:
 201                 g_string_append_printf (str, "%u", g_value_get_uint (value));
 202
 203                 return TRUE;
 204
 205         case G_TYPE_INT64:
 206                 g_string_append_printf (str, "%"G_GINT64_FORMAT,
 207                                         g_value_get_int64 (value));
 208
 209                 return TRUE;
 210
 211         case G_TYPE_UINT64:
 212                 g_string_append_printf (str, "%"G_GUINT64_FORMAT,
 213                                         g_value_get_uint64 (value));
 214
 215                 return TRUE;
 216
 217         case G_TYPE_LONG:
 218                 g_string_append_printf (str, "%ld", g_value_get_long (value));
 219
 220                 return TRUE;
 221
 222         case G_TYPE_ULONG:
 223                 g_string_append_printf (str, "%lu", g_value_get_ulong (value));
 224
 225                 return TRUE;
 226
 227         case G_TYPE_FLOAT:
 228                 g_string_append (str,
 229                                  g_ascii_dtostr (buf,
 230                                                  sizeof (buf),
 231                                                  g_value_get_float (value)));
 232
 233                 return TRUE;
 234
 235         case G_TYPE_DOUBLE:
 236                 g_string_append (str,
 237                                  g_ascii_dtostr (buf,
 238                                                  sizeof (buf),
 239                                                  g_value_get_double (value)));
 240
 241                 return TRUE;
 242
 243         case G_TYPE_BOOLEAN:
 244                 /* We don't want to convert to "TRUE"/"FALSE" */
 245                 if (g_value_get_boolean (value))
 246                         g_string_append_c (str, '1');
 247                 else
 248                         g_string_append_c (str, '0');
 249
 250                 return TRUE;
 251
 252         default:
 253                 /* Try to convert */
 254                 if (g_value_type_transformable (G_VALUE_TYPE (value),
 255                                                 G_TYPE_STRING)) {
 256                         g_value_init (&transformed_value, G_TYPE_STRING);
 257
 258                         g_value_transform (value, &transformed_value);
 259
 260                         tmp = g_value_get_string (&transformed_value);
 261                         if (tmp != NULL)
 262                                 xml_util_add_content (str, tmp);
 263
 264                         g_value_unset (&transformed_value);
 265
 266                         return TRUE;
 267                 } else {
 268                         g_warning ("Failed to transform value of type %s "
 269                                    "to a string", G_VALUE_TYPE_NAME (value));
 270
 271                         return FALSE;
 272                 }
 273         }
 274 }