gobject/genums.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  * Copyright (C) 1998-1999, 2000-2001 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,
  89                                       G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT);
  90   g_assert (type == G_TYPE_ENUM);
  91
  92   /* G_TYPE_FLAGS
  93    */
  94   info.class_size = sizeof (GFlagsClass);
  95   type = g_type_register_fundamental (G_TYPE_FLAGS, "GFlags", &info, &finfo,
  96                                       G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT);
  97   g_assert (type == G_TYPE_FLAGS);
  98 }
  99
 100 static void
 101 value_flags_enum_init (GValue *value)
 102 {
 103   value->data[0].v_long = 0;
 104 }
 105
 106 static void
 107 value_flags_enum_copy_value (const GValue *src_value,
 108                              GValue       *dest_value)
 109 {
 110   dest_value->data[0].v_long = src_value->data[0].v_long;
 111 }
 112
 113 static gchar*
 114 value_flags_enum_collect_value (GValue      *value,
 115                                 guint        n_collect_values,
 116                                 GTypeCValue *collect_values,
 117                                 guint        collect_flags)
 118 {
 119   value->data[0].v_long = collect_values[0].v_int;
 120
 121   return NULL;
 122 }
 123
 124 static gchar*
 125 value_flags_enum_lcopy_value (const GValue *value,
 126                               guint         n_collect_values,
 127                               GTypeCValue  *collect_values,
 128                               guint         collect_flags)
 129 {
 130   gint *int_p = collect_values[0].v_pointer;
 131
 132   if (!int_p)
 133     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 134
 135   *int_p = value->data[0].v_long;
 136
 137   return NULL;
 138 }
 139
 140 GType
 141 g_enum_register_static (const gchar      *name,
 142                         const GEnumValue *const_static_values)
 143 {
 144   GTypeInfo enum_type_info = {
 145     sizeof (GEnumClass), /* class_size */
 146     NULL,                /* base_init */
 147     NULL,                /* base_finalize */
 148     (GClassInitFunc) g_enum_class_init,
 149     NULL,                /* class_finalize */
 150     NULL,                /* class_data */
 151     0,                   /* instance_size */
 152     0,                   /* n_preallocs */
 153     NULL,                /* instance_init */
 154     NULL,                /* value_table */
 155   };
 156   GType type;
 157
 158   g_return_val_if_fail (name != NULL, 0);
 159   g_return_val_if_fail (const_static_values != NULL, 0);
 160
 161   enum_type_info.class_data = const_static_values;
 162
 163   type = g_type_register_static (G_TYPE_ENUM, name, &enum_type_info, 0);
 164
 165   return type;
 166 }
 167
 168 GType
 169 g_flags_register_static (const gchar       *name,
 170                          const GFlagsValue *const_static_values)
 171 {
 172   GTypeInfo flags_type_info = {
 173     sizeof (GFlagsClass), /* class_size */
 174     NULL,                 /* base_init */
 175     NULL,                 /* base_finalize */
 176     (GClassInitFunc) g_flags_class_init,
 177     NULL,                 /* class_finalize */
 178     NULL,                 /* class_data */
 179     0,                    /* instance_size */
 180     0,                    /* n_preallocs */
 181     NULL,                 /* instance_init */
 182     NULL,                 /* value_table */
 183   };
 184   GType type;
 185
 186   g_return_val_if_fail (name != NULL, 0);
 187   g_return_val_if_fail (const_static_values != NULL, 0);
 188
 189   flags_type_info.class_data = const_static_values;
 190
 191   type = g_type_register_static (G_TYPE_FLAGS, name, &flags_type_info, 0);
 192
 193   return type;
 194 }
 195
 196 void
 197 g_enum_complete_type_info (GType             g_enum_type,
 198                            GTypeInfo        *info,
 199                            const GEnumValue *const_values)
 200 {
 201   g_return_if_fail (G_TYPE_IS_ENUM (g_enum_type));
 202   g_return_if_fail (info != NULL);
 203   g_return_if_fail (const_values != NULL);
 204
 205   info->class_size = sizeof (GEnumClass);
 206   info->base_init = NULL;
 207   info->base_finalize = NULL;
 208   info->class_init = (GClassInitFunc) g_enum_class_init;
 209   info->class_finalize = NULL;
 210   info->class_data = const_values;
 211 }
 212
 213 void
 214 g_flags_complete_type_info (GType              g_flags_type,
 215                             GTypeInfo         *info,
 216                             const GFlagsValue *const_values)
 217 {
 218   g_return_if_fail (G_TYPE_IS_FLAGS (g_flags_type));
 219   g_return_if_fail (info != NULL);
 220   g_return_if_fail (const_values != NULL);
 221
 222   info->class_size = sizeof (GFlagsClass);
 223   info->base_init = NULL;
 224   info->base_finalize = NULL;
 225   info->class_init = (GClassInitFunc) g_flags_class_init;
 226   info->class_finalize = NULL;
 227   info->class_data = const_values;
 228 }
 229
 230 static void
 231 g_enum_class_init (GEnumClass *class,
 232                    gpointer    class_data)
 233 {
 234   g_return_if_fail (G_IS_ENUM_CLASS (class));
 235
 236   class->minimum = 0;
 237   class->maximum = 0;
 238   class->n_values = 0;
 239   class->values = class_data;
 240
 241   if (class->values)
 242     {
 243       GEnumValue *values;
 244
 245       class->minimum = class->values->value;
 246       class->maximum = class->values->value;
 247       for (values = class->values; values->value_name; values++)
 248         {
 249           class->minimum = MIN (class->minimum, values->value);
 250           class->maximum = MAX (class->maximum, values->value);
 251           class->n_values++;
 252         }
 253     }
 254 }
 255
 256 static void
 257 g_flags_class_init (GFlagsClass *class,
 258                     gpointer     class_data)
 259 {
 260   g_return_if_fail (G_IS_FLAGS_CLASS (class));
 261
 262   class->mask = 0;
 263   class->n_values = 0;
 264   class->values = class_data;
 265
 266   if (class->values)
 267     {
 268       GFlagsValue *values;
 269
 270       for (values = class->values; values->value_name; values++)
 271         {
 272           class->mask |= values->value;
 273           class->n_values++;
 274         }
 275     }
 276 }
 277
 278 GEnumValue*
 279 g_enum_get_value_by_name (GEnumClass  *enum_class,
 280                           const gchar *name)
 281 {
 282   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 283   g_return_val_if_fail (name != NULL, NULL);
 284
 285   if (enum_class->n_values)
 286     {
 287       GEnumValue *enum_value;
 288
 289       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 290         if (strcmp (name, enum_value->value_name) == 0)
 291           return enum_value;
 292     }
 293
 294   return NULL;
 295 }
 296
 297 GFlagsValue*
 298 g_flags_get_value_by_name (GFlagsClass *flags_class,
 299                            const gchar *name)
 300 {
 301   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 302   g_return_val_if_fail (name != NULL, NULL);
 303
 304   if (flags_class->n_values)
 305     {
 306       GFlagsValue *flags_value;
 307
 308       for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
 309         if (strcmp (name, flags_value->value_name) == 0)
 310           return flags_value;
 311     }
 312
 313   return NULL;
 314 }
 315
 316 GEnumValue*
 317 g_enum_get_value_by_nick (GEnumClass  *enum_class,
 318                           const gchar *nick)
 319 {
 320   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 321   g_return_val_if_fail (nick != NULL, NULL);
 322
 323   if (enum_class->n_values)
 324     {
 325       GEnumValue *enum_value;
 326
 327       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 328         if (enum_value->value_nick && strcmp (nick, enum_value->value_nick) == 0)
 329           return enum_value;
 330     }
 331
 332   return NULL;
 333 }
 334
 335 GFlagsValue*
 336 g_flags_get_value_by_nick (GFlagsClass *flags_class,
 337                            const gchar *nick)
 338 {
 339   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 340   g_return_val_if_fail (nick != NULL, NULL);
 341
 342   if (flags_class->n_values)
 343     {
 344       GFlagsValue *flags_value;
 345
 346       for (flags_value = flags_class->values; flags_value->value_nick; flags_value++)
 347         if (flags_value->value_nick && strcmp (nick, flags_value->value_nick) == 0)
 348           return flags_value;
 349     }
 350
 351   return NULL;
 352 }
 353
 354 GEnumValue*
 355 g_enum_get_value (GEnumClass *enum_class,
 356                   gint        value)
 357 {
 358   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
 359
 360   if (enum_class->n_values)
 361     {
 362       GEnumValue *enum_value;
 363
 364       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
 365         if (enum_value->value == value)
 366           return enum_value;
 367     }
 368
 369   return NULL;
 370 }
 371
 372 GFlagsValue*
 373 g_flags_get_first_value (GFlagsClass *flags_class,
 374                          guint        value)
 375 {
 376   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
 377
 378   if (flags_class->n_values)
 379     {
 380       GFlagsValue *flags_value;
 381
 382       for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
 383         if ((flags_value->value & value) == flags_value->value)
 384           return flags_value;
 385     }
 386
 387   return NULL;
 388 }
 389
 390 void
 391 g_value_set_enum (GValue *value,
 392                   gint    v_enum)
 393 {
 394   g_return_if_fail (G_VALUE_HOLDS_ENUM (value));
 395
 396   value->data[0].v_long = v_enum;
 397 }
 398
 399 gint
 400 g_value_get_enum (const GValue *value)
 401 {
 402   g_return_val_if_fail (G_VALUE_HOLDS_ENUM (value), 0);
 403
 404   return value->data[0].v_long;
 405 }
 406
 407 void
 408 g_value_set_flags (GValue *value,
 409                    guint   v_flags)
 410 {
 411   g_return_if_fail (G_VALUE_HOLDS_FLAGS (value));
 412
 413   value->data[0].v_ulong = v_flags;
 414 }
 415
 416 guint
 417 g_value_get_flags (const GValue *value)
 418 {
 419   g_return_val_if_fail (G_VALUE_HOLDS_FLAGS (value), 0);
 420
 421   return value->data[0].v_ulong;
 422 }