libanjuta/anjuta-serializer.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  *  anjuta-serializer.c
   4  *  Copyright (C) 2000 Naba Kumar  <naba@gnome.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program 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
  14  *  GNU Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20 #include <stdio.h>
  21 #include <anjuta-enum-types.h>
  22 #include "anjuta-serializer.h"
  23
  24 static void anjuta_serializer_class_init(AnjutaSerializerClass *klass);
  25 static void anjuta_serializer_init(AnjutaSerializer *sp);
  26 static void anjuta_serializer_finalize(GObject *object);
  27
  28 struct _AnjutaSerializerPrivate {
  29         AnjutaSerializerMode mode;
  30         gchar *filepath;
  31         FILE *stream;
  32 };
  33
  34 static GObjectClass *parent_class = NULL;
  35
  36 enum
  37 {
  38         PROP_0,
  39         PROP_FILEPATH,
  40         PROP_MODE
  41 };
  42
  43 GType
  44 anjuta_serializer_get_type (void)
  45 {
  46         static GType type = 0;
  47
  48         if(type == 0) {
  49                 static const GTypeInfo our_info = {
  50                         sizeof (AnjutaSerializerClass),
  51                         NULL,
  52                         NULL,
  53                         (GClassInitFunc)anjuta_serializer_class_init,
  54                         NULL,
  55                         NULL,
  56                         sizeof (AnjutaSerializer),
  57                         0,
  58                         (GInstanceInitFunc)anjuta_serializer_init,
  59                 };
  60
  61                 type = g_type_register_static(G_TYPE_OBJECT,
  62                                                                           "AnjutaSerializer", &our_info, 0);
  63         }
  64
  65         return type;
  66 }
  67
  68 static void
  69 anjuta_serializer_set_property (GObject * object,
  70                                                                 guint property_id,
  71                                                                 const GValue * value, GParamSpec * pspec)
  72 {
  73         AnjutaSerializer *self = ANJUTA_SERIALIZER (object);
  74         g_return_if_fail (value != NULL);
  75         g_return_if_fail (pspec != NULL);
  76
  77         switch (property_id)
  78         {
  79         case PROP_MODE:
  80                 self->priv->mode = g_value_get_enum (value);
  81                 break;
  82         case PROP_FILEPATH:
  83                 g_free (self->priv->filepath);
  84                 self->priv->filepath = g_value_dup_string (value);
  85                 if (self->priv->stream)
  86                         fclose (self->priv->stream);
  87                 if (self->priv->mode == ANJUTA_SERIALIZER_READ)
  88                         self->priv->stream = fopen (self->priv->filepath, "r");
  89                 else
  90                         self->priv->stream = fopen (self->priv->filepath, "w");
  91                 if (self->priv->stream == NULL)
  92                 {
  93                         /*
  94                         g_warning ("Could not open %s for serialization: %s",
  95                                            self->priv->filepath, g_strerror (errno));
  96                         */
  97                 }
  98                 break;
  99         default:
 100                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 101         }
 102 }
 103
 104 static void
 105 anjuta_serializer_get_property (GObject * object,
 106                                                                 guint property_id,
 107                                                                 GValue * value, GParamSpec * pspec)
 108 {
 109         AnjutaSerializer *self = ANJUTA_SERIALIZER (object);
 110
 111         g_return_if_fail(value != NULL);
 112         g_return_if_fail(pspec != NULL);
 113
 114         switch (property_id)
 115         {
 116         case PROP_MODE:
 117                 g_value_set_enum (value, self->priv->mode);
 118                 break;
 119         case PROP_FILEPATH:
 120                 g_value_set_string (value, self->priv->filepath);
 121                 break;
 122         default:
 123                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 124         }
 125 }
 126
 127 static void
 128 anjuta_serializer_class_init (AnjutaSerializerClass *klass)
 129 {
 130         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 131
 132         parent_class = g_type_class_peek_parent(klass);
 133         object_class->finalize = anjuta_serializer_finalize;
 134         object_class->set_property = anjuta_serializer_set_property;
 135         object_class->get_property = anjuta_serializer_get_property;
 136
 137         g_object_class_install_property (object_class,
 138                          PROP_FILEPATH,
 139                          g_param_spec_string ("filepath",
 140                                          "File path",
 141                                          "Used to store and retrieve the stream"
 142                                          "translateable",
 143                                          NULL,
 144                                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 145         g_object_class_install_property (object_class,
 146                          PROP_MODE,
 147                          g_param_spec_enum ("mode",
 148                                          "Serialization mode",
 149                                          "Used to decide read or write operation",
 150                                          ANJUTA_TYPE_SERIALIZER_MODE,
 151                                          ANJUTA_SERIALIZER_READ,
 152                                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 153 }
 154
 155 static void
 156 anjuta_serializer_init (AnjutaSerializer *obj)
 157 {
 158         obj->priv = g_new0 (AnjutaSerializerPrivate, 1);
 159 }
 160
 161 static void
 162 anjuta_serializer_finalize (GObject *object)
 163 {
 164         AnjutaSerializer *cobj;
 165         cobj = ANJUTA_SERIALIZER(object);
 166
 167         g_free (cobj->priv->filepath);
 168         if (cobj->priv->stream)
 169                 fclose (cobj->priv->stream);
 170         g_free (cobj->priv);
 171         G_OBJECT_CLASS (parent_class)->finalize (object);
 172 }
 173
 174 AnjutaSerializer *
 175 anjuta_serializer_new (const gchar *filepath, AnjutaSerializerMode mode)
 176 {
 177         AnjutaSerializer *obj;
 178
 179         obj = ANJUTA_SERIALIZER (g_object_new (ANJUTA_TYPE_SERIALIZER,
 180                                                                                    "mode", mode,
 181                                                                                    "filepath", filepath, NULL));
 182         if (obj->priv->stream == NULL)
 183         {
 184                 g_object_unref (obj);
 185                 return NULL;
 186         }
 187         return obj;
 188 }
 189
 190 static gboolean
 191 anjuta_serializer_write_buffer (AnjutaSerializer *serializer,
 192                                                                 const gchar *name, const gchar *value)
 193 {
 194         gint length;
 195         gchar *buffer;
 196
 197         g_return_val_if_fail (ANJUTA_IS_SERIALIZER (serializer), FALSE);
 198         g_return_val_if_fail (serializer->priv->stream != NULL, FALSE);
 199         g_return_val_if_fail (serializer->priv->mode == ANJUTA_SERIALIZER_WRITE,
 200                                                   FALSE);
 201         g_return_val_if_fail (name != NULL, FALSE);
 202         g_return_val_if_fail (value != NULL, FALSE);
 203
 204         buffer = g_strconcat (name, ": ", value, NULL);
 205         length = strlen (buffer);
 206         if (fprintf (serializer->priv->stream, "%d\n", length) < 1)
 207         {
 208                 g_free (buffer);
 209                 return FALSE;
 210         }
 211         if (fwrite (buffer, length, 1, serializer->priv->stream) < 1)
 212         {
 213                 g_free (buffer);
 214                 return FALSE;
 215         }
 216         if (fprintf (serializer->priv->stream, "\n") < 0)
 217         {
 218                 g_free (buffer);
 219                 return FALSE;
 220         }
 221         g_free (buffer);
 222         return TRUE;
 223 }
 224
 225 static gboolean
 226 anjuta_serializer_read_buffer (AnjutaSerializer *serializer,
 227                                                            const gchar *name, gchar **value)
 228 {
 229         gint length;
 230         gchar *buffer;
 231
 232         g_return_val_if_fail (ANJUTA_IS_SERIALIZER (serializer), FALSE);
 233         g_return_val_if_fail (serializer->priv->stream != NULL, FALSE);
 234         g_return_val_if_fail (serializer->priv->mode == ANJUTA_SERIALIZER_READ,
 235                                                   FALSE);
 236         g_return_val_if_fail (name != NULL, FALSE);
 237         g_return_val_if_fail (value != NULL, FALSE);
 238
 239         if (fscanf (serializer->priv->stream, "%d\n", &length) < 1)
 240                 return FALSE;
 241
 242         buffer = g_new0 (gchar, length + 1);
 243         if (fread (buffer, length, 1, serializer->priv->stream) < 1)
 244         {
 245                 g_free (buffer);
 246                 return FALSE;
 247         }
 248         if (fscanf (serializer->priv->stream, "\n") < 0)
 249         {
 250                 g_free (buffer);
 251                 return FALSE;
 252         }
 253         if (strncmp (buffer, name, strlen (name)) !=  0)
 254         {
 255                 g_free (buffer);
 256                 return FALSE;
 257         }
 258         if (strncmp (buffer + strlen (name), ": ", 2) !=  0)
 259         {
 260                 g_free (buffer);
 261                 return FALSE;
 262         }
 263         strcpy (buffer, buffer + strlen (name) + 2);
 264         *value = buffer;
 265
 266         return TRUE;
 267 }
 268
 269 gboolean
 270 anjuta_serializer_write_int (AnjutaSerializer *serializer,
 271                                                          const gchar *name, gint value)
 272 {
 273         gchar buffer[64];
 274         snprintf (buffer, 64, "%d", value);
 275         return anjuta_serializer_write_buffer (serializer, name, buffer);
 276 }
 277
 278 gboolean
 279 anjuta_serializer_write_float (AnjutaSerializer *serializer,
 280                                                            const gchar *name, gfloat value)
 281 {
 282         gchar buffer[64];
 283         snprintf (buffer, 64, "%f", value);
 284         return anjuta_serializer_write_buffer (serializer, name, buffer);
 285 }
 286
 287 gboolean
 288 anjuta_serializer_write_string (AnjutaSerializer *serializer,
 289                                                                 const gchar *name, const gchar *value)
 290 {
 291         if (value)
 292                 return anjuta_serializer_write_buffer (serializer, name, value);
 293         else
 294                 return anjuta_serializer_write_buffer (serializer, name, "(null)");
 295 }
 296
 297 gboolean
 298 anjuta_serializer_read_int (AnjutaSerializer *serializer,
 299                                                          const gchar *name, gint *value)
 300 {
 301         gchar *buffer;
 302
 303         g_return_val_if_fail (value != NULL, FALSE);
 304
 305         if (!anjuta_serializer_read_buffer (serializer, name, &buffer))
 306                 return FALSE;
 307         *value = atoi (buffer);
 308         g_free (buffer);
 309         return TRUE;
 310 }
 311
 312 gboolean
 313 anjuta_serializer_read_float (AnjutaSerializer *serializer,
 314                                                           const gchar *name, gfloat *value)
 315 {
 316         gchar *buffer;
 317
 318         g_return_val_if_fail (value != NULL, FALSE);
 319
 320         if (!anjuta_serializer_read_buffer (serializer, name, &buffer))
 321                 return FALSE;
 322         *value = atof (buffer);
 323         g_free (buffer);
 324         return TRUE;
 325 }
 326
 327 gboolean
 328 anjuta_serializer_read_string (AnjutaSerializer *serializer,
 329                                                            const gchar *name, gchar **value,
 330                                                            gboolean replace)
 331 {
 332         gchar *buffer;
 333
 334         g_return_val_if_fail (value != NULL, FALSE);
 335
 336         if (!anjuta_serializer_read_buffer (serializer, name, &buffer))
 337                 return FALSE;
 338         if (replace)
 339                 g_free (*value);
 340         if (strcmp (buffer, "(null)") == 0)
 341         {
 342                 g_free (buffer);
 343                 *value = NULL;
 344         }
 345         else
 346         {
 347                 *value = buffer;
 348         }
 349         return TRUE;
 350 }