~ubuntu-branches/debian/jessie/glib2.0/jessie

« back to all changes in this revision

Viewing changes to gobject/genums.c

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo Noronha Silva
  • Date: 2009-02-15 13:00:43 UTC
  • mto: (1.4.3 upstream)
  • mto: This revision was merged to the branch mainline in revision 70.
  • Revision ID: james.westby@ubuntu.com-20090215130043-6snh45flhit8oalb
Tags: upstream-2.18.4
ImportĀ upstreamĀ versionĀ 2.18.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
 * MT safe
22
22
 */
23
23
 
24
 
#include        <string.h>
25
 
 
26
 
#include        "genums.h"
27
 
 
28
 
#include        "gvalue.h"
29
 
#include        "gvaluecollector.h"
30
 
 
31
 
#include        "gobjectalias.h"
 
24
#include "config.h"
 
25
 
 
26
#include <string.h>
 
27
 
 
28
#include "genums.h"
 
29
#include "gvalue.h"
 
30
#include "gvaluecollector.h"
 
31
#include "gobjectalias.h"
 
32
 
 
33
 
 
34
/**
 
35
 * SECTION:enumerations_flags
 
36
 * @short_description: Enumeration and flags types
 
37
 * @see_also:#GParamSpecEnum, #GParamSpecFlags, g_param_spec_enum(),
 
38
 * g_param_spec_flags(),
 
39
 *
 
40
 * <link linkend="glib-mkenums">glib-mkenums</link>
 
41
 * @title: Enumeration and Flag Types
 
42
 *
 
43
 * The GLib type system provides fundamental types for enumeration and
 
44
 * flags types. (Flags types are like enumerations, but allow their
 
45
 * values to be combined by bitwise or). A registered enumeration or
 
46
 * flags type associates a name and a nickname with each allowed
 
47
 * value, and the methods g_enum_get_value_by_name(),
 
48
 * g_enum_get_value_by_nick(), g_flags_get_value_by_name() and
 
49
 * g_flags_get_value_by_nick() can look up values by their name or
 
50
 * nickname.  When an enumeration or flags type is registered with the
 
51
 * GLib type system, it can be used as value type for object
 
52
 * properties, using g_param_spec_enum() or g_param_spec_flags().
 
53
 *
 
54
 * GObject ships with a utility called <link
 
55
 * linkend="glib-mkenums">glib-mkenums</link> that can construct
 
56
 * suitable type registration functions from C enumeration
 
57
 * definitions.
 
58
 */
32
59
 
33
60
 
34
61
/* --- prototypes --- */
138
165
  return NULL;
139
166
}
140
167
 
 
168
/**
 
169
 * g_enum_register_static:
 
170
 * @name: A nul-terminated string used as the name of the new type.
 
171
 * @const_static_values: An array of #GEnumValue structs for the possible
 
172
 *  enumeration values. The array is terminated by a struct with all
 
173
 *  members being 0. GObject keeps a reference to the data, so it cannot
 
174
 *  be stack-allocated.
 
175
 *
 
176
 * Registers a new static enumeration type with the name @name.
 
177
 *
 
178
 * It is normally more convenient to let <link
 
179
 * linkend="glib-mkenums">glib-mkenums</link> generate a
 
180
 * my_enum_get_type() function from a usual C enumeration definition
 
181
 * than to write one yourself using g_enum_register_static().
 
182
 *
 
183
 * Returns: The new type identifier.
 
184
 */
141
185
GType
142
186
g_enum_register_static (const gchar      *name,
143
187
                        const GEnumValue *const_static_values)
166
210
  return type;
167
211
}
168
212
 
 
213
/**
 
214
 * g_flags_register_static:
 
215
 * @name: A nul-terminated string used as the name of the new type.
 
216
 * @const_static_values: An array of #GFlagsValue structs for the possible
 
217
 *  flags values. The array is terminated by a struct with all members being 0.
 
218
 *  GObject keeps a reference to the data, so it cannot be stack-allocated.
 
219
 *
 
220
 * Registers a new static flags type with the name @name.
 
221
 *
 
222
 * It is normally more convenient to let <link
 
223
 * linkend="glib-mkenums">glib-mkenums</link> generate a
 
224
 * my_flags_get_type() function from a usual C enumeration definition
 
225
 * than to write one yourself using g_flags_register_static().
 
226
 *
 
227
 * Returns: The new type identifier.
 
228
 */
169
229
GType
170
230
g_flags_register_static (const gchar       *name,
171
231
                         const GFlagsValue *const_static_values)
194
254
  return type;
195
255
}
196
256
 
 
257
/**
 
258
 * g_enum_complete_type_info:
 
259
 * @g_enum_type: the type identifier of the type being completed
 
260
 * @info: the #GTypeInfo struct to be filled in
 
261
 * @const_values: An array of #GEnumValue structs for the possible
 
262
 *  enumeration values. The array is terminated by a struct with all
 
263
 *  members being 0.
 
264
 *
 
265
 * This function is meant to be called from the complete_type_info()
 
266
 * function of a #GTypePlugin implementation, as in the following
 
267
 * example:
 
268
 *
 
269
 * |[
 
270
 * static void
 
271
 * my_enum_complete_type_info (GTypePlugin     *plugin,
 
272
 *                             GType            g_type,
 
273
 *                             GTypeInfo       *info,
 
274
 *                             GTypeValueTable *value_table)
 
275
 * {
 
276
 *   static const GEnumValue values[] = {
 
277
 *     { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
 
278
 *     { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
 
279
 *     { 0, NULL, NULL }
 
280
 *   };
 
281
 *
 
282
 *   g_enum_complete_type_info (type, info, values);
 
283
 * }
 
284
 * ]|
 
285
 */
197
286
void
198
287
g_enum_complete_type_info (GType             g_enum_type,
199
288
                           GTypeInfo        *info,
211
300
  info->class_data = const_values;
212
301
}
213
302
 
 
303
/**
 
304
 * g_flags_complete_type_info:
 
305
 * @g_flags_type: the type identifier of the type being completed
 
306
 * @info: the #GTypeInfo struct to be filled in
 
307
 * @const_values: An array of #GFlagsValue structs for the possible
 
308
 *  enumeration values. The array is terminated by a struct with all
 
309
 *  members being 0.
 
310
 *
 
311
 * This function is meant to be called from the complete_type_info()
 
312
 * function of a #GTypePlugin implementation, see the example for
 
313
 * g_enum_complete_type_info() above.
 
314
 */
214
315
void
215
316
g_flags_complete_type_info (GType              g_flags_type,
216
317
                            GTypeInfo         *info,
276
377
    }
277
378
}
278
379
 
 
380
/**
 
381
 * g_enum_get_value_by_name:
 
382
 * @enum_class: a #GEnumClass
 
383
 * @name: the name to look up
 
384
 *
 
385
 * Looks up a #GEnumValue by name.
 
386
 *
 
387
 * Returns: the #GEnumValue with name @name, or %NULL if the
 
388
 *          enumeration doesn't have a member with that name
 
389
 */
279
390
GEnumValue*
280
391
g_enum_get_value_by_name (GEnumClass  *enum_class,
281
392
                          const gchar *name)
295
406
  return NULL;
296
407
}
297
408
 
 
409
/**
 
410
 * g_flags_get_value_by_name:
 
411
 * @flags_class: a #GFlagsClass
 
412
 * @name: the name to look up
 
413
 *
 
414
 * Looks up a #GFlagsValue by name.
 
415
 *
 
416
 * Returns: the #GFlagsValue with name @name, or %NULL if there is no
 
417
 *          flag with that name
 
418
 */
298
419
GFlagsValue*
299
420
g_flags_get_value_by_name (GFlagsClass *flags_class,
300
421
                           const gchar *name)
314
435
  return NULL;
315
436
}
316
437
 
 
438
/**
 
439
 * g_enum_get_value_by_nick:
 
440
 * @enum_class: a #GEnumClass
 
441
 * @nick: the nickname to look up
 
442
 *
 
443
 * Looks up a #GEnumValue by nickname.
 
444
 *
 
445
 * Returns: the #GEnumValue with nickname @nick, or %NULL if the
 
446
 *          enumeration doesn't have a member with that nickname
 
447
 */
317
448
GEnumValue*
318
449
g_enum_get_value_by_nick (GEnumClass  *enum_class,
319
450
                          const gchar *nick)
333
464
  return NULL;
334
465
}
335
466
 
 
467
/**
 
468
 * g_flags_get_value_by_nick:
 
469
 * @flags_class: a #GFlagsClass
 
470
 * @nick: the nickname to look up
 
471
 *
 
472
 * Looks up a #GFlagsValue by nickname.
 
473
 *
 
474
 * Returns: the #GFlagsValue with nickname @nick, or %NULL if there is
 
475
 *          no flag with that nickname
 
476
 */
336
477
GFlagsValue*
337
478
g_flags_get_value_by_nick (GFlagsClass *flags_class,
338
479
                           const gchar *nick)
352
493
  return NULL;
353
494
}
354
495
 
 
496
/**
 
497
 * g_enum_get_value:
 
498
 * @enum_class: a #GEnumClass
 
499
 * @value: the value to look up
 
500
 *
 
501
 * Returns the #GEnumValue for a value.
 
502
 *
 
503
 * Returns: the #GEnumValue for @value, or %NULL if @value is not a
 
504
 *          member of the enumeration
 
505
 */
355
506
GEnumValue*
356
507
g_enum_get_value (GEnumClass *enum_class,
357
508
                  gint        value)
370
521
  return NULL;
371
522
}
372
523
 
 
524
/**
 
525
 * g_flags_get_first_value:
 
526
 * @flags_class: a #GFlagsClass
 
527
 * @value: the value
 
528
 *
 
529
 * Returns the first #GFlagsValue which is set in @value.
 
530
 *
 
531
 * Returns: the first #GFlagsValue which is set in @value, or %NULL if
 
532
 *          none is set
 
533
 */
373
534
GFlagsValue*
374
535
g_flags_get_first_value (GFlagsClass *flags_class,
375
536
                         guint        value)
397
558
  return NULL;
398
559
}
399
560
 
 
561
/**
 
562
 * g_value_set_enum:
 
563
 * @value: a valid #GValue whose type is derived from %G_TYPE_ENUM
 
564
 * @v_enum: enum value to be set
 
565
 *
 
566
 * Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.
 
567
 */
400
568
void
401
569
g_value_set_enum (GValue *value,
402
570
                  gint    v_enum)
406
574
  value->data[0].v_long = v_enum;
407
575
}
408
576
 
 
577
/**
 
578
 * g_value_get_enum:
 
579
 * @value: a valid #GValue whose type is derived from %G_TYPE_ENUM
 
580
 *
 
581
 * Get the contents of a %G_TYPE_ENUM #GValue.
 
582
 *
 
583
 * Returns: enum contents of @value
 
584
 */
409
585
gint
410
586
g_value_get_enum (const GValue *value)
411
587
{
414
590
  return value->data[0].v_long;
415
591
}
416
592
 
 
593
/**
 
594
 * g_value_set_flags:
 
595
 * @value: a valid #GValue whose type is derived from %G_TYPE_FLAGS
 
596
 * @v_flags: flags value to be set
 
597
 *
 
598
 * Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.
 
599
 */
417
600
void
418
601
g_value_set_flags (GValue *value,
419
602
                   guint   v_flags)
423
606
  value->data[0].v_ulong = v_flags;
424
607
}
425
608
 
 
609
/**
 
610
 * g_value_get_flags:
 
611
 * @value: a valid #GValue whose type is derived from %G_TYPE_FLAGS
 
612
 *
 
613
 * Get the contents of a %G_TYPE_FLAGS #GValue.
 
614
 *
 
615
 * Returns: flags contents of @value
 
616
 */
426
617
guint
427
618
g_value_get_flags (const GValue *value)
428
619
{