gobject/genums.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  * Copyright (C) 1998, 1999, 2000 Tim Janik and Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General
  15  * Public License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * MT safe
  22  */
  23
  24 #include        <string.h>
  25
  26 #include        "genums.h"
  27
  28 #include        "gvalue.h"
  29 #include        "gvaluecollector.h"
  30
  31
  32 /* --- prototypes --- */
  33 static void     g_enum_class_init               (GEnumClass     *class,
  34                                                  gpointer        class_data);
  35 static void     g_flags_class_init              (GFlagsClass    *class,
  36                                                  gpointer        class_data);
  37 static void     value_flags_enum_init           (GValue         *value);
  38 static void     value_flags_enum_copy_value     (const GValue   *src_value,
  39                                                  GValue         *dest_value);
  40 static gchar*   value_flags_enum_collect_value  (GValue         *value,
  41                                                  guint           n_collect_values,
  42                                                  GTypeCValue    *collect_values,
  43                                                  guint           collect_flags);
  44 static gchar*   value_flags_enum_lcopy_value    (const GValue   *value,
  45                                                  guint           n_collect_values,
  46                                                  GTypeCValue    *collect_values,
  47                                                  guint           collect_flags);
  48
  49
  50 /* --- functions --- */
  51 void
  52 g_enum_types_init (void)        /* sync with gtype.c */
  53 {
  54   static gboolean initialized = FALSE;
  55   static const GTypeValueTable flags_enum_value_table = {
  56     value_flags_enum_init,          /* value_init */
  57     NULL,                           /* value_free */
  58     value_flags_enum_copy_value,    /* value_copy */
  59     NULL,                           /* value_peek_pointer */
  60     "i",                            /* collect_format */
  61     value_flags_enum_collect_value, /* collect_value */
  62     "p",                            /* lcopy_format */
  63     value_flags_enum_lcopy_value,   /* lcopy_value */
  64   };
  65   static GTypeInfo info = {
  66     0,                          /* class_size */
  67     NULL,                       /* base_init */
  68     NULL,                       /* base_destroy */
  69     NULL,                       /* class_init */
  70     NULL,                       /* class_destroy */
  71     NULL,                       /* class_data */
  72     0,                          /* instance_size */
  73     0,                          /* n_preallocs */
  74     NULL,                       /* instance_init */
  75     &flags_enum_value_table,    /* value_table */
  76   };
  77   static const GTypeFundamentalInfo finfo = {
  78     G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_DERIVABLE,
  79   };
  80   GType type;
  81
  82   g_return_if_fail (initialized == FALSE);
  83   initialized = TRUE;
  84
  85   /* G_TYPE_ENUM
  86    */
  87   info.class_size = sizeof (GEnumClass);
  88   type = g_type_register_fundamental (G_TYPE_ENUM, "GEnum", &info, &finfo, G_TYPE_FLAG_ABSTRACT);
  89   g_assert (type == G_TYPE_ENUM);
  90
  91   /* G_TYPE_FLAGS
  92    */
  93   info.class_size = sizeof (GFlagsClass);
  94   type = g_type_register_fundamental (G_TYPE_FLAGS, "GFlags", &info, &finfo, G_TYPE_FLAG_ABSTRACT);
  95   g_assert (type == G_TYPE_FLAGS);
  96 }
  97
  98 static void
  99 value_flags_enum_init (GValue *value)
 100 {
 101   value->data[0].v_long = 0;
 102 }
 103
 104 static void
 105 value_flags_enum_copy_value (const GValue *src_value,
 106                              GValue       *dest_value)
 107 {
 108   dest_value->data[0].v_long = src_value->data[0].v_long;
 109 }
 110
 111 static gchar*
 112 value_flags_enum_collect_value (GValue      *value,
 113                                 guint        n_collect_values,
 114                                 GTypeCValue *collect_values,
 115                                 guint        collect_flags)
 116 {
 117   value->data[0].v_long = collect_values[0].v_int;
 118
 119   return NULL;
 120 }
 121
 122 static gchar*
 123 value_flags_enum_lcopy_value (const GValue *value,
 124                               guint         n_collect_values,
 125                               GTypeCValue  *collect_values,
 126                               guint         collect_flags)
 127 {
 128   gint *int_p = collect_values[0].v_pointer;
 129
 130   if (!int_p)
 131     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 132
 133   *int_p = value->data[0].v_long;
 134
 135   return NULL;
 136 }
 137
 138 GType
 139 g_enum_register_static (const gchar      *name,
 140                         const GEnumValue *const_static_values)
 141 {
 142   GTypeInfo enum_type_info = {
 143     sizeof (GEnumClass), /* class_size */
 144     NULL,                /* base_init */
 145     NULL,                /* base_finalize */
 146     (GClassInitFunc) g_enum_class_init,
 147     NULL,                /* class_finalize */
 148     NULL,                /* class_data */
 149     0,                   /* instance_size */
 150     0,                   /* n_preallocs */
 151     NULL,                /* instance_init */
 152     NULL,                /* value_table */
 153   };
 154   GType type;
 155
 156   g_return_val_if_fail (name != NULL, 0);
 157   g_return_val_if_fail (const_static_values != NULL, 0);
 158
 159   enum_type_info.class_data = const_static_values;
 160
 161   type = g_type_register_static (G_TYPE_ENUM, name, &enum_type_info, 0);
 162
 163   return type;
 164 }
 165
 166 GType
 167 g_flags_register_static (const gchar       *name,
 168                          const GFlagsValue *const_static_values)
 169 {
 170   GTypeInfo flags_type_info = {
 171     sizeof (GFlagsClass), /* class_size */
 172     NULL,                 /* base_init */
 173     NULL,                 /* base_finalize */
 174     (GClassInitFunc) g_flags_class_init,
 175     NULL,                 /* class_finalize */
 176     NULL,                 /* class_data */
 177     0,                    /* instance_size */
 178     0,                    /* n_preallocs */
 179     NULL,                 /* instance_init */
 180     NULL,                 /* value_table */
 181   };
 182   GType type;
 183
 184   g_return_val_if_fail (name != NULL, 0);
 185   g_return_val_if_fail (const_static_values != NULL, 0);
 186
 187   flags_type_info.class_data = const_static_values;
 188
 189   type = g_type_register_static (G_TYPE_FLAGS, name, &flags_type_info, 0);
 190
 191   return type;
 192 }
 193
 194 void
 195 g_enum_complete_type_info (GType             g_enum_type,
 196                            GTypeInfo        *info,
 197                            const GEnumValue *const_values)
 198 {
 199   g_return_if_fail (G_TYPE_IS_ENUM (g_enum_type));
 200   g_return_if_fail (info != NULL);
 201   g_return_if_fail (const_values != NULL);
 202
 203   info->class_size = sizeof (GEnumClass);
 204   info->base_init = NULL;
 205   info->base_finalize = NULL;
 206   info->class_init = (GClassInitFunc) g_enum_class_init;
 207   info->class_finalize = NULL;
 208   info->class_data = const_values;
 209 }
 210
 211 void
 212 g_flags_complete_type_info (GType              g_flags_type,
 213                             GTypeInfo         *info,
 214                             const GFlagsValue *const_values)
 215 {
 216   g_return_if_fail (G_TYPE_IS_FLAGS (g_flags_type));
 217   g_return_if_fail (info != NULL);
 218   g_return_if_fail (const_values != NULL);
 219
 220   info->class_size = sizeof (GFlagsClass);
 221   info->base_init = NULL;
 222   info->base_finalize = NULL;
 223   info->class_init = (GClassInitFunc) g_flags_class_init;
 224   info->class_finalize = NULL;
 225   info->class_data = const_values;
 226 }
 227
 228 static void
 229 g_enum_class_init (GEnumClass *class,
 230                    gpointer    class_data)
 231 {
 232   g_return_if_fail (G_IS_ENUM_CLASS (class));
 233
 234   class->minimum = 0;
 235   class->maximum = 0;
 236   class->n_values = 0;
 237   class->values = class_data;
 238
 239   if (class->values)
 240     {
 241       GEnumValue *values;
 242
 243       class->minimum = class->values->value;
 244       class->maximum = class->values->value;
 245       for (values = class->values; values->value_name; values++)
 246         {
 247           class->minimum = MIN (class->minimum, values->value);
 248           class->maximum = MAX (class->maximum, values->value);
 249           class->n_values++;
 250         }
 251     }
 252 }
 253
 254 static void
 255 g_flags_class_init (GFlagsClass *class,
 256                     gpointer     class_data)
 257 {
 258   g_return_if_fail (G_IS_FLAGS_CLASS (class));
 259
 260   class->mask = 0;
 261   class->n_values = 0;
 262   class->values = class_data;
 263
 264   if (class->values)
 265     {
 266       GFlagsValue *values;
 267
 268       for (values = class->values; values->value_name; values++)
 269         {
 270           class->mask |= values->value;
 271           class->n_values++;
 272         }
 273     }
 274 }
 275
 276 GEnumValue*
 277 g_enum_get_value_by_name (GEnumClass  *enum_class,
 278                           const gchar *name)
 279 {
 280   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 281   g_return_val_if_fail (name != NULL, NULL);
 282
 283   if (enum_class->n_values)
 284     {
 285       GEnumValue *enum_value;
 286
 287       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 288         if (strcmp (name, enum_value->value_name) == 0)
 289           return enum_value;
 290     }
 291
 292   return NULL;
 293 }
 294
 295 GFlagsValue*
 296 g_flags_get_value_by_name (GFlagsClass *flags_class,
 297                            const gchar *name)
 298 {
 299   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 300   g_return_val_if_fail (name != NULL, NULL);
 301
 302   if (flags_class->n_values)
 303     {
 304       GFlagsValue *flags_value;
 305
 306       for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
 307         if (strcmp (name, flags_value->value_name) == 0)
 308           return flags_value;
 309     }
 310
 311   return NULL;
 312 }
 313
 314 GEnumValue*
 315 g_enum_get_value_by_nick (GEnumClass  *enum_class,
 316                           const gchar *nick)
 317 {
 318   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 319   g_return_val_if_fail (nick != NULL, NULL);
 320
 321   if (enum_class->n_values)
 322     {
 323       GEnumValue *enum_value;
 324
 325       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 326         if (enum_value->value_nick && strcmp (nick, enum_value->value_nick) == 0)
 327           return enum_value;
 328     }
 329
 330   return NULL;
 331 }
 332
 333 GFlagsValue*
 334 g_flags_get_value_by_nick (GFlagsClass *flags_class,
 335                            const gchar *nick)
 336 {
 337   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 338   g_return_val_if_fail (nick != NULL, NULL);
 339
 340   if (flags_class->n_values)
 341     {
 342       GFlagsValue *flags_value;
 343
 344       for (flags_value = flags_class->values; flags_value->value_nick; flags_value++)
 345         if (flags_value->value_nick && strcmp (nick, flags_value->value_nick) == 0)
 346           return flags_value;
 347     }
 348
 349   return NULL;
 350 }
 351
 352 GEnumValue*
 353 g_enum_get_value (GEnumClass *enum_class,
 354                   gint        value)
 355 {
 356   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 357
 358   if (enum_class->n_values)
 359     {
 360       GEnumValue *enum_value;
 361
 362       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 363         if (enum_value->value == value)
 364           return enum_value;
 365     }
 366
 367   return NULL;
 368 }
 369
 370 GFlagsValue*
 371 g_flags_get_first_value (GFlagsClass *flags_class,
 372                          guint        value)
 373 {
 374   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 375
 376   if (flags_class->n_values)
 377     {
 378       GFlagsValue *flags_value;
 379
 380       for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
 381         if ((flags_value->value & value) > 0)
 382           return flags_value;
 383     }
 384
 385   return NULL;
 386 }
 387
 388 void
 389 g_value_set_enum (GValue *value,
 390                   gint    v_enum)
 391 {
 392   g_return_if_fail (G_IS_VALUE_ENUM (value));
 393
 394   value->data[0].v_long = v_enum;
 395 }
 396
 397 gint
 398 g_value_get_enum (const GValue *value)
 399 {
 400   g_return_val_if_fail (G_IS_VALUE_ENUM (value), 0);
 401
 402   return value->data[0].v_long;
 403 }
 404
 405 void
 406 g_value_set_flags (GValue *value,
 407                    guint   v_flags)
 408 {
 409   g_return_if_fail (G_IS_VALUE_FLAGS (value));
 410
 411   value->data[0].v_ulong = v_flags;
 412 }
 413
 414 guint
 415 g_value_get_flags (const GValue *value)
 416 {
 417   g_return_val_if_fail (G_IS_VALUE_FLAGS (value), 0);
 418
 419   return value->data[0].v_ulong;
 420 }