LCOV - code coverage report
Current view: top level - gobject - genums.c (source / functions) Coverage Total Hit
Test: unnamed Lines: 85.9 % 177 152
Test Date: 2024-11-26 05:23:01 Functions: 87.5 % 24 21
Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* GObject - GLib Type, Object, Parameter and Signal Library
       2                 :             :  * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
       3                 :             :  *
       4                 :             :  * SPDX-License-Identifier: LGPL-2.1-or-later
       5                 :             :  *
       6                 :             :  * This library is free software; you can redistribute it and/or
       7                 :             :  * modify it under the terms of the GNU Lesser General Public
       8                 :             :  * License as published by the Free Software Foundation; either
       9                 :             :  * version 2.1 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                 :             :  * Lesser General Public License for more details.
      15                 :             :  *
      16                 :             :  * You should have received a copy of the GNU Lesser General
      17                 :             :  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
      18                 :             :  */
      19                 :             : 
      20                 :             : /*
      21                 :             :  * MT safe
      22                 :             :  */
      23                 :             : 
      24                 :             : #include "config.h"
      25                 :             : 
      26                 :             : #include <string.h>
      27                 :             : 
      28                 :             : #include "genums.h"
      29                 :             : #include "gtype-private.h"
      30                 :             : #include "gvalue.h"
      31                 :             : #include "gvaluecollector.h"
      32                 :             : 
      33                 :             : 
      34                 :             : /* --- prototypes --- */
      35                 :             : static void     g_enum_class_init               (GEnumClass     *class,
      36                 :             :                                                  gpointer        class_data);
      37                 :             : static void     g_flags_class_init              (GFlagsClass    *class,
      38                 :             :                                                  gpointer        class_data);
      39                 :             : static void     value_flags_enum_init           (GValue         *value);
      40                 :             : static void     value_flags_enum_copy_value     (const GValue   *src_value,
      41                 :             :                                                  GValue         *dest_value);
      42                 :             : static gchar*   value_flags_enum_collect_value  (GValue         *value,
      43                 :             :                                                  guint           n_collect_values,
      44                 :             :                                                  GTypeCValue    *collect_values,
      45                 :             :                                                  guint           collect_flags);
      46                 :             : static gchar*   value_flags_enum_lcopy_value    (const GValue   *value,
      47                 :             :                                                  guint           n_collect_values,
      48                 :             :                                                  GTypeCValue    *collect_values,
      49                 :             :                                                  guint           collect_flags);
      50                 :             : 
      51                 :             : /* --- functions --- */
      52                 :             : void
      53                 :         545 : _g_enum_types_init (void)
      54                 :             : {
      55                 :             :   static gboolean initialized = FALSE;
      56                 :             :   static const GTypeValueTable flags_enum_value_table = {
      57                 :             :     value_flags_enum_init,          /* value_init */
      58                 :             :     NULL,                           /* value_free */
      59                 :             :     value_flags_enum_copy_value,    /* value_copy */
      60                 :             :     NULL,                           /* value_peek_pointer */
      61                 :             :     "i",                          /* collect_format */
      62                 :             :     value_flags_enum_collect_value, /* collect_value */
      63                 :             :     "p",                          /* lcopy_format */
      64                 :             :     value_flags_enum_lcopy_value,   /* lcopy_value */
      65                 :             :   };
      66                 :         545 :   GTypeInfo info = {
      67                 :             :     0,                          /* class_size */
      68                 :             :     NULL,                       /* base_init */
      69                 :             :     NULL,                       /* base_destroy */
      70                 :             :     NULL,                       /* class_init */
      71                 :             :     NULL,                       /* class_destroy */
      72                 :             :     NULL,                       /* class_data */
      73                 :             :     0,                          /* instance_size */
      74                 :             :     0,                          /* n_preallocs */
      75                 :             :     NULL,                       /* instance_init */
      76                 :             :     &flags_enum_value_table,    /* value_table */
      77                 :             :   };
      78                 :             :   static const GTypeFundamentalInfo finfo = {
      79                 :             :     G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_DERIVABLE,
      80                 :             :   };
      81                 :             :   GType type G_GNUC_UNUSED  /* when compiling with G_DISABLE_ASSERT */;
      82                 :             :   
      83                 :         545 :   g_return_if_fail (initialized == FALSE);
      84                 :         545 :   initialized = TRUE;
      85                 :             :   
      86                 :             :   /* G_TYPE_ENUM
      87                 :             :    */
      88                 :         545 :   info.class_size = sizeof (GEnumClass);
      89                 :         545 :   type = g_type_register_fundamental (G_TYPE_ENUM, g_intern_static_string ("GEnum"), &info, &finfo,
      90                 :             :                                       G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT);
      91                 :         545 :   g_assert (type == G_TYPE_ENUM);
      92                 :             :   
      93                 :             :   /* G_TYPE_FLAGS
      94                 :             :    */
      95                 :         545 :   info.class_size = sizeof (GFlagsClass);
      96                 :         545 :   type = g_type_register_fundamental (G_TYPE_FLAGS, g_intern_static_string ("GFlags"), &info, &finfo,
      97                 :             :                                       G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT);
      98                 :         545 :   g_assert (type == G_TYPE_FLAGS);
      99                 :             : }
     100                 :             : 
     101                 :             : static void
     102                 :        8638 : value_flags_enum_init (GValue *value)
     103                 :             : {
     104                 :        8638 :   value->data[0].v_long = 0;
     105                 :        8638 : }
     106                 :             : 
     107                 :             : static void
     108                 :           0 : value_flags_enum_copy_value (const GValue *src_value,
     109                 :             :                              GValue       *dest_value)
     110                 :             : {
     111                 :           0 :   dest_value->data[0].v_long = src_value->data[0].v_long;
     112                 :           0 : }
     113                 :             : 
     114                 :             : static gchar*
     115                 :        9303 : value_flags_enum_collect_value (GValue      *value,
     116                 :             :                                 guint        n_collect_values,
     117                 :             :                                 GTypeCValue *collect_values,
     118                 :             :                                 guint        collect_flags)
     119                 :             : {
     120                 :        9303 :   if (G_VALUE_HOLDS_ENUM (value))
     121                 :        6198 :     value->data[0].v_long = collect_values[0].v_int;
     122                 :             :   else
     123                 :        3105 :     value->data[0].v_ulong = (guint) collect_values[0].v_int;
     124                 :             : 
     125                 :        9303 :   return NULL;
     126                 :             : }
     127                 :             : 
     128                 :             : static gchar*
     129                 :          46 : value_flags_enum_lcopy_value (const GValue *value,
     130                 :             :                               guint         n_collect_values,
     131                 :             :                               GTypeCValue  *collect_values,
     132                 :             :                               guint         collect_flags)
     133                 :             : {
     134                 :          46 :   gint *int_p = collect_values[0].v_pointer;
     135                 :             : 
     136                 :          46 :   g_return_val_if_fail (int_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
     137                 :             : 
     138                 :          46 :   *int_p = value->data[0].v_long;
     139                 :             :   
     140                 :          46 :   return NULL;
     141                 :             : }
     142                 :             : 
     143                 :             : /**
     144                 :             :  * g_enum_register_static:
     145                 :             :  * @name: A nul-terminated string used as the name of the new type.
     146                 :             :  * @const_static_values: (array zero-terminated=1): An array of
     147                 :             :  *  #GEnumValue structs for the possible enumeration values. The array is
     148                 :             :  *  terminated by a struct with all members being 0. GObject keeps a
     149                 :             :  *  reference to the data, so it cannot be stack-allocated.
     150                 :             :  *
     151                 :             :  * Registers a new static enumeration type with the name @name.
     152                 :             :  *
     153                 :             :  * It is normally more convenient to let [glib-mkenums][glib-mkenums],
     154                 :             :  * generate a my_enum_get_type() function from a usual C enumeration
     155                 :             :  * definition  than to write one yourself using g_enum_register_static().
     156                 :             :  *
     157                 :             :  * Returns: The new type identifier.
     158                 :             :  */
     159                 :             : GType
     160                 :        1181 : g_enum_register_static (const gchar      *name,
     161                 :             :                         const GEnumValue *const_static_values)
     162                 :             : {
     163                 :        1181 :   GTypeInfo enum_type_info = {
     164                 :             :     sizeof (GEnumClass), /* class_size */
     165                 :             :     NULL,                /* base_init */
     166                 :             :     NULL,                /* base_finalize */
     167                 :             :     (GClassInitFunc) g_enum_class_init,
     168                 :             :     NULL,                /* class_finalize */
     169                 :             :     NULL,                /* class_data */
     170                 :             :     0,                   /* instance_size */
     171                 :             :     0,                   /* n_preallocs */
     172                 :             :     NULL,                /* instance_init */
     173                 :             :     NULL,                /* value_table */
     174                 :             :   };
     175                 :             :   GType type;
     176                 :             :   
     177                 :        1181 :   g_return_val_if_fail (name != NULL, 0);
     178                 :        1181 :   g_return_val_if_fail (const_static_values != NULL, 0);
     179                 :             :   
     180                 :        1181 :   enum_type_info.class_data = const_static_values;
     181                 :             :   
     182                 :        1181 :   type = g_type_register_static (G_TYPE_ENUM, name, &enum_type_info, 0);
     183                 :             :   
     184                 :        1181 :   return type;
     185                 :             : }
     186                 :             : 
     187                 :             : /**
     188                 :             :  * g_flags_register_static:
     189                 :             :  * @name: A nul-terminated string used as the name of the new type.
     190                 :             :  * @const_static_values: (array zero-terminated=1): An array of
     191                 :             :  *  #GFlagsValue structs for the possible flags values. The array is
     192                 :             :  *  terminated by a struct with all members being 0. GObject keeps a
     193                 :             :  *  reference to the data, so it cannot be stack-allocated.
     194                 :             :  *
     195                 :             :  * Registers a new static flags type with the name @name.
     196                 :             :  *
     197                 :             :  * It is normally more convenient to let [glib-mkenums][glib-mkenums]
     198                 :             :  * generate a my_flags_get_type() function from a usual C enumeration
     199                 :             :  * definition than to write one yourself using g_flags_register_static().
     200                 :             :  *
     201                 :             :  * Returns: The new type identifier.
     202                 :             :  */
     203                 :             : GType
     204                 :         663 : g_flags_register_static (const gchar       *name,
     205                 :             :                          const GFlagsValue *const_static_values)
     206                 :             : {
     207                 :         663 :   GTypeInfo flags_type_info = {
     208                 :             :     sizeof (GFlagsClass), /* class_size */
     209                 :             :     NULL,                 /* base_init */
     210                 :             :     NULL,                 /* base_finalize */
     211                 :             :     (GClassInitFunc) g_flags_class_init,
     212                 :             :     NULL,                 /* class_finalize */
     213                 :             :     NULL,                 /* class_data */
     214                 :             :     0,                    /* instance_size */
     215                 :             :     0,                    /* n_preallocs */
     216                 :             :     NULL,                 /* instance_init */
     217                 :             :     NULL,                 /* value_table */
     218                 :             :   };
     219                 :             :   GType type;
     220                 :             :   
     221                 :         663 :   g_return_val_if_fail (name != NULL, 0);
     222                 :         663 :   g_return_val_if_fail (const_static_values != NULL, 0);
     223                 :             :   
     224                 :         663 :   flags_type_info.class_data = const_static_values;
     225                 :             :   
     226                 :         663 :   type = g_type_register_static (G_TYPE_FLAGS, name, &flags_type_info, 0);
     227                 :             :   
     228                 :         663 :   return type;
     229                 :             : }
     230                 :             : 
     231                 :             : /**
     232                 :             :  * g_enum_complete_type_info:
     233                 :             :  * @g_enum_type: the type identifier of the type being completed
     234                 :             :  * @info: (out callee-allocates): the #GTypeInfo struct to be filled in
     235                 :             :  * @const_values: An array of #GEnumValue structs for the possible
     236                 :             :  *  enumeration values. The array is terminated by a struct with all
     237                 :             :  *  members being 0.
     238                 :             :  *
     239                 :             :  * This function is meant to be called from the `complete_type_info`
     240                 :             :  * function of a #GTypePlugin implementation, as in the following
     241                 :             :  * example:
     242                 :             :  *
     243                 :             :  * |[<!-- language="C" --> 
     244                 :             :  * static void
     245                 :             :  * my_enum_complete_type_info (GTypePlugin     *plugin,
     246                 :             :  *                             GType            g_type,
     247                 :             :  *                             GTypeInfo       *info,
     248                 :             :  *                             GTypeValueTable *value_table)
     249                 :             :  * {
     250                 :             :  *   static const GEnumValue values[] = {
     251                 :             :  *     { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
     252                 :             :  *     { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
     253                 :             :  *     { 0, NULL, NULL }
     254                 :             :  *   };
     255                 :             :  *
     256                 :             :  *   g_enum_complete_type_info (type, info, values);
     257                 :             :  * }
     258                 :             :  * ]|
     259                 :             :  */
     260                 :             : void
     261                 :           0 : g_enum_complete_type_info (GType             g_enum_type,
     262                 :             :                            GTypeInfo        *info,
     263                 :             :                            const GEnumValue *const_values)
     264                 :             : {
     265                 :           0 :   g_return_if_fail (G_TYPE_IS_ENUM (g_enum_type));
     266                 :           0 :   g_return_if_fail (info != NULL);
     267                 :           0 :   g_return_if_fail (const_values != NULL);
     268                 :             :   
     269                 :           0 :   info->class_size = sizeof (GEnumClass);
     270                 :           0 :   info->base_init = NULL;
     271                 :           0 :   info->base_finalize = NULL;
     272                 :           0 :   info->class_init = (GClassInitFunc) g_enum_class_init;
     273                 :           0 :   info->class_finalize = NULL;
     274                 :           0 :   info->class_data = const_values;
     275                 :             : }
     276                 :             : 
     277                 :             : /**
     278                 :             :  * g_flags_complete_type_info:
     279                 :             :  * @g_flags_type: the type identifier of the type being completed
     280                 :             :  * @info: (out callee-allocates): the #GTypeInfo struct to be filled in
     281                 :             :  * @const_values: An array of #GFlagsValue structs for the possible
     282                 :             :  *  enumeration values. The array is terminated by a struct with all
     283                 :             :  *  members being 0.
     284                 :             :  *
     285                 :             :  * This function is meant to be called from the complete_type_info()
     286                 :             :  * function of a #GTypePlugin implementation, see the example for
     287                 :             :  * g_enum_complete_type_info() above.
     288                 :             :  */
     289                 :             : void
     290                 :           0 : g_flags_complete_type_info (GType              g_flags_type,
     291                 :             :                             GTypeInfo         *info,
     292                 :             :                             const GFlagsValue *const_values)
     293                 :             : {
     294                 :           0 :   g_return_if_fail (G_TYPE_IS_FLAGS (g_flags_type));
     295                 :           0 :   g_return_if_fail (info != NULL);
     296                 :           0 :   g_return_if_fail (const_values != NULL);
     297                 :             :   
     298                 :           0 :   info->class_size = sizeof (GFlagsClass);
     299                 :           0 :   info->base_init = NULL;
     300                 :           0 :   info->base_finalize = NULL;
     301                 :           0 :   info->class_init = (GClassInitFunc) g_flags_class_init;
     302                 :           0 :   info->class_finalize = NULL;
     303                 :           0 :   info->class_data = const_values;
     304                 :             : }
     305                 :             : 
     306                 :             : static void
     307                 :         949 : g_enum_class_init (GEnumClass *class,
     308                 :             :                    gpointer    class_data)
     309                 :             : {
     310                 :         949 :   g_return_if_fail (G_IS_ENUM_CLASS (class));
     311                 :             :   
     312                 :         949 :   class->minimum = 0;
     313                 :         949 :   class->maximum = 0;
     314                 :         949 :   class->n_values = 0;
     315                 :         949 :   class->values = class_data;
     316                 :             :   
     317                 :         949 :   if (class->values)
     318                 :             :     {
     319                 :             :       GEnumValue *values;
     320                 :             :       
     321                 :         949 :       class->minimum = class->values->value;
     322                 :         949 :       class->maximum = class->values->value;
     323                 :        5241 :       for (values = class->values; values->value_name; values++)
     324                 :             :         {
     325                 :        4292 :           class->minimum = MIN (class->minimum, values->value);
     326                 :        4292 :           class->maximum = MAX (class->maximum, values->value);
     327                 :        4292 :           class->n_values++;
     328                 :             :         }
     329                 :             :     }
     330                 :             : }
     331                 :             : 
     332                 :             : static void
     333                 :         613 : g_flags_class_init (GFlagsClass *class,
     334                 :             :                     gpointer     class_data)
     335                 :             : {
     336                 :         613 :   g_return_if_fail (G_IS_FLAGS_CLASS (class));
     337                 :             :   
     338                 :         613 :   class->mask = 0;
     339                 :         613 :   class->n_values = 0;
     340                 :         613 :   class->values = class_data;
     341                 :             :   
     342                 :         613 :   if (class->values)
     343                 :             :     {
     344                 :             :       GFlagsValue *values;
     345                 :             :       
     346                 :        4338 :       for (values = class->values; values->value_name; values++)
     347                 :             :         {
     348                 :        3725 :           class->mask |= values->value;
     349                 :        3725 :           class->n_values++;
     350                 :             :         }
     351                 :             :     }
     352                 :             : }
     353                 :             : 
     354                 :             : /**
     355                 :             :  * g_enum_get_value_by_name:
     356                 :             :  * @enum_class: a #GEnumClass
     357                 :             :  * @name: the name to look up
     358                 :             :  *
     359                 :             :  * Looks up a #GEnumValue by name.
     360                 :             :  *
     361                 :             :  * Returns: (transfer none) (nullable): the #GEnumValue with name @name,
     362                 :             :  *          or %NULL if the enumeration doesn't have a member
     363                 :             :  *          with that name
     364                 :             :  */
     365                 :             : GEnumValue*
     366                 :           2 : g_enum_get_value_by_name (GEnumClass  *enum_class,
     367                 :             :                           const gchar *name)
     368                 :             : {
     369                 :           2 :   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
     370                 :           2 :   g_return_val_if_fail (name != NULL, NULL);
     371                 :             :   
     372                 :           2 :   if (enum_class->n_values)
     373                 :             :     {
     374                 :             :       GEnumValue *enum_value;
     375                 :             :       
     376                 :           7 :       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
     377                 :           6 :         if (strcmp (name, enum_value->value_name) == 0)
     378                 :           1 :           return enum_value;
     379                 :             :     }
     380                 :             :   
     381                 :           1 :   return NULL;
     382                 :             : }
     383                 :             : 
     384                 :             : /**
     385                 :             :  * g_flags_get_value_by_name:
     386                 :             :  * @flags_class: a #GFlagsClass
     387                 :             :  * @name: the name to look up
     388                 :             :  *
     389                 :             :  * Looks up a #GFlagsValue by name.
     390                 :             :  *
     391                 :             :  * Returns: (transfer none) (nullable): the #GFlagsValue with name @name,
     392                 :             :  *          or %NULL if there is no flag with that name
     393                 :             :  */
     394                 :             : GFlagsValue*
     395                 :           2 : g_flags_get_value_by_name (GFlagsClass *flags_class,
     396                 :             :                            const gchar *name)
     397                 :             : {
     398                 :           2 :   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
     399                 :           2 :   g_return_val_if_fail (name != NULL, NULL);
     400                 :             :   
     401                 :           2 :   if (flags_class->n_values)
     402                 :             :     {
     403                 :             :       GFlagsValue *flags_value;
     404                 :             :       
     405                 :           9 :       for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
     406                 :           8 :         if (strcmp (name, flags_value->value_name) == 0)
     407                 :           1 :           return flags_value;
     408                 :             :     }
     409                 :             :   
     410                 :           1 :   return NULL;
     411                 :             : }
     412                 :             : 
     413                 :             : /**
     414                 :             :  * g_enum_get_value_by_nick:
     415                 :             :  * @enum_class: a #GEnumClass
     416                 :             :  * @nick: the nickname to look up
     417                 :             :  *
     418                 :             :  * Looks up a #GEnumValue by nickname.
     419                 :             :  *
     420                 :             :  * Returns: (transfer none) (nullable): the #GEnumValue with nickname @nick,
     421                 :             :  *          or %NULL if the enumeration doesn't have a member
     422                 :             :  *          with that nickname
     423                 :             :  */
     424                 :             : GEnumValue*
     425                 :          11 : g_enum_get_value_by_nick (GEnumClass  *enum_class,
     426                 :             :                           const gchar *nick)
     427                 :             : {
     428                 :          11 :   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
     429                 :          11 :   g_return_val_if_fail (nick != NULL, NULL);
     430                 :             :   
     431                 :          11 :   if (enum_class->n_values)
     432                 :             :     {
     433                 :             :       GEnumValue *enum_value;
     434                 :             :       
     435                 :          28 :       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
     436                 :          27 :         if (enum_value->value_nick && strcmp (nick, enum_value->value_nick) == 0)
     437                 :          10 :           return enum_value;
     438                 :             :     }
     439                 :             :   
     440                 :           1 :   return NULL;
     441                 :             : }
     442                 :             : 
     443                 :             : /**
     444                 :             :  * g_flags_get_value_by_nick:
     445                 :             :  * @flags_class: a #GFlagsClass
     446                 :             :  * @nick: the nickname to look up
     447                 :             :  *
     448                 :             :  * Looks up a #GFlagsValue by nickname.
     449                 :             :  *
     450                 :             :  * Returns: (transfer none) (nullable): the #GFlagsValue with nickname @nick,
     451                 :             :  *          or %NULL if there is no flag with that nickname
     452                 :             :  */
     453                 :             : GFlagsValue*
     454                 :           6 : g_flags_get_value_by_nick (GFlagsClass *flags_class,
     455                 :             :                            const gchar *nick)
     456                 :             : {
     457                 :           6 :   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
     458                 :           6 :   g_return_val_if_fail (nick != NULL, NULL);
     459                 :             :   
     460                 :           6 :   if (flags_class->n_values)
     461                 :             :     {
     462                 :             :       GFlagsValue *flags_value;
     463                 :             :       
     464                 :          18 :       for (flags_value = flags_class->values; flags_value->value_nick; flags_value++)
     465                 :          17 :         if (flags_value->value_nick && strcmp (nick, flags_value->value_nick) == 0)
     466                 :           5 :           return flags_value;
     467                 :             :     }
     468                 :             :   
     469                 :           1 :   return NULL;
     470                 :             : }
     471                 :             : 
     472                 :             : /**
     473                 :             :  * g_enum_get_value:
     474                 :             :  * @enum_class: a #GEnumClass
     475                 :             :  * @value: the value to look up
     476                 :             :  *
     477                 :             :  * Returns the #GEnumValue for a value.
     478                 :             :  *
     479                 :             :  * Returns: (transfer none) (nullable): the #GEnumValue for @value, or %NULL
     480                 :             :  *          if @value is not a member of the enumeration
     481                 :             :  */
     482                 :             : GEnumValue*
     483                 :       15781 : g_enum_get_value (GEnumClass *enum_class,
     484                 :             :                   gint        value)
     485                 :             : {
     486                 :       15781 :   g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), NULL);
     487                 :             :   
     488                 :       15781 :   if (enum_class->n_values)
     489                 :             :     {
     490                 :             :       GEnumValue *enum_value;
     491                 :             :       
     492                 :       31438 :       for (enum_value = enum_class->values; enum_value->value_name; enum_value++)
     493                 :       31435 :         if (enum_value->value == value)
     494                 :       15778 :           return enum_value;
     495                 :             :     }
     496                 :             :   
     497                 :           3 :   return NULL;
     498                 :             : }
     499                 :             : 
     500                 :             : /**
     501                 :             :  * g_flags_get_first_value:
     502                 :             :  * @flags_class: a #GFlagsClass
     503                 :             :  * @value: the value
     504                 :             :  *
     505                 :             :  * Returns the first #GFlagsValue which is set in @value.
     506                 :             :  *
     507                 :             :  * Returns: (transfer none) (nullable): the first #GFlagsValue which is set in
     508                 :             :  *          @value, or %NULL if none is set
     509                 :             :  */
     510                 :             : GFlagsValue*
     511                 :          69 : g_flags_get_first_value (GFlagsClass *flags_class,
     512                 :             :                          guint        value)
     513                 :             : {
     514                 :          69 :   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
     515                 :             :   
     516                 :          69 :   if (flags_class->n_values)
     517                 :             :     {
     518                 :             :       GFlagsValue *flags_value;
     519                 :             : 
     520                 :          69 :       if (value == 0)
     521                 :             :         {
     522                 :          36 :           for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
     523                 :          35 :             if (flags_value->value == 0)
     524                 :          34 :               return flags_value;
     525                 :             :         }
     526                 :             :       else
     527                 :             :         {
     528                 :         150 :           for (flags_value = flags_class->values; flags_value->value_name; flags_value++)
     529                 :         145 :             if (flags_value->value != 0 && (flags_value->value & value) == flags_value->value)
     530                 :          29 :               return flags_value;
     531                 :             :         }      
     532                 :             :     }
     533                 :             :   
     534                 :           6 :   return NULL;
     535                 :             : }
     536                 :             : 
     537                 :             : /**
     538                 :             :  * g_enum_to_string:
     539                 :             :  * @g_enum_type: the type identifier of a #GEnumClass type
     540                 :             :  * @value: the value
     541                 :             :  *
     542                 :             :  * Pretty-prints @value in the form of the enum’s name.
     543                 :             :  *
     544                 :             :  * This is intended to be used for debugging purposes. The format of the output
     545                 :             :  * may change in the future.
     546                 :             :  *
     547                 :             :  * Returns: (transfer full): a newly-allocated text string
     548                 :             :  *
     549                 :             :  * Since: 2.54
     550                 :             :  */
     551                 :             : gchar *
     552                 :          28 : g_enum_to_string (GType g_enum_type,
     553                 :             :                   gint  value)
     554                 :             : {
     555                 :             :   gchar *result;
     556                 :             :   GEnumClass *enum_class;
     557                 :             :   GEnumValue *enum_value;
     558                 :             : 
     559                 :          28 :   g_return_val_if_fail (G_TYPE_IS_ENUM (g_enum_type), NULL);
     560                 :             : 
     561                 :          28 :   enum_class = g_type_class_ref (g_enum_type);
     562                 :             : 
     563                 :             :   /* Already warned */
     564                 :          28 :   if (enum_class == NULL)
     565                 :           0 :     return g_strdup_printf ("%d", value);
     566                 :             : 
     567                 :          28 :   enum_value = g_enum_get_value (enum_class, value);
     568                 :             : 
     569                 :          28 :   if (enum_value == NULL)
     570                 :           1 :     result = g_strdup_printf ("%d", value);
     571                 :             :   else
     572                 :          54 :     result = g_strdup (enum_value->value_name);
     573                 :             : 
     574                 :          28 :   g_type_class_unref (enum_class);
     575                 :          28 :   return result;
     576                 :             : }
     577                 :             : 
     578                 :             : /*
     579                 :             :  * g_flags_get_value_string:
     580                 :             :  * @flags_class: a #GFlagsClass
     581                 :             :  * @value: the value
     582                 :             :  *
     583                 :             :  * Pretty-prints @value in the form of the flag names separated by ` | ` and
     584                 :             :  * sorted. Any extra bits will be shown at the end as a hexadecimal number.
     585                 :             :  *
     586                 :             :  * This is intended to be used for debugging purposes. The format of the output
     587                 :             :  * may change in the future.
     588                 :             :  *
     589                 :             :  * Returns: (transfer full): a newly-allocated text string
     590                 :             :  *
     591                 :             :  * Since: 2.54
     592                 :             :  */
     593                 :             : static gchar *
     594                 :           7 : g_flags_get_value_string (GFlagsClass *flags_class,
     595                 :             :                           guint        value)
     596                 :             : {
     597                 :             :   GString *str;
     598                 :             :   GFlagsValue *flags_value;
     599                 :             : 
     600                 :           7 :   g_return_val_if_fail (G_IS_FLAGS_CLASS (flags_class), NULL);
     601                 :             : 
     602                 :           7 :   str = g_string_new (NULL);
     603                 :             : 
     604                 :          21 :   while ((str->len == 0 || value != 0) &&
     605                 :           9 :          (flags_value = g_flags_get_first_value (flags_class, value)) != NULL)
     606                 :             :     {
     607                 :           5 :       if (str->len > 0)
     608                 :           2 :         g_string_append (str, " | ");
     609                 :             : 
     610                 :           5 :       g_string_append (str, flags_value->value_name);
     611                 :             : 
     612                 :           5 :       value &= ~flags_value->value;
     613                 :             :     }
     614                 :             : 
     615                 :             :   /* Show the extra bits */
     616                 :           7 :   if (value != 0 || str->len == 0)
     617                 :             :     {
     618                 :           4 :       if (str->len > 0)
     619                 :           2 :         g_string_append (str, " | ");
     620                 :             : 
     621                 :           4 :       g_string_append_printf (str, "0x%x", value);
     622                 :             :     }
     623                 :             : 
     624                 :           7 :   return g_string_free (str, FALSE);
     625                 :             : }
     626                 :             : 
     627                 :             : /**
     628                 :             :  * g_flags_to_string:
     629                 :             :  * @flags_type: the type identifier of a #GFlagsClass type
     630                 :             :  * @value: the value
     631                 :             :  *
     632                 :             :  * Pretty-prints @value in the form of the flag names separated by ` | ` and
     633                 :             :  * sorted. Any extra bits will be shown at the end as a hexadecimal number.
     634                 :             :  *
     635                 :             :  * This is intended to be used for debugging purposes. The format of the output
     636                 :             :  * may change in the future.
     637                 :             :  *
     638                 :             :  * Returns: (transfer full): a newly-allocated text string
     639                 :             :  *
     640                 :             :  * Since: 2.54
     641                 :             :  */
     642                 :             : gchar *
     643                 :           7 : g_flags_to_string (GType flags_type,
     644                 :             :                    guint value)
     645                 :             : {
     646                 :             :   gchar *result;
     647                 :             :   GFlagsClass *flags_class;
     648                 :             : 
     649                 :           7 :   g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
     650                 :             : 
     651                 :           7 :   flags_class = g_type_class_ref (flags_type);
     652                 :             : 
     653                 :             :   /* Already warned */
     654                 :           7 :   if (flags_class == NULL)
     655                 :           0 :     return NULL;
     656                 :             : 
     657                 :           7 :   result = g_flags_get_value_string (flags_class, value);
     658                 :             : 
     659                 :           7 :   g_type_class_unref (flags_class);
     660                 :           7 :   return result;
     661                 :             : }
     662                 :             : 
     663                 :             : 
     664                 :             : /**
     665                 :             :  * g_value_set_enum:
     666                 :             :  * @value: a valid #GValue whose type is derived from %G_TYPE_ENUM
     667                 :             :  * @v_enum: enum value to be set
     668                 :             :  *
     669                 :             :  * Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.
     670                 :             :  */
     671                 :             : void
     672                 :          51 : g_value_set_enum (GValue *value,
     673                 :             :                   gint    v_enum)
     674                 :             : {
     675                 :          51 :   g_return_if_fail (G_VALUE_HOLDS_ENUM (value));
     676                 :             :   
     677                 :          51 :   value->data[0].v_long = v_enum;
     678                 :             : }
     679                 :             : 
     680                 :             : /**
     681                 :             :  * g_value_get_enum:
     682                 :             :  * @value: a valid #GValue whose type is derived from %G_TYPE_ENUM
     683                 :             :  *
     684                 :             :  * Get the contents of a %G_TYPE_ENUM #GValue.
     685                 :             :  *
     686                 :             :  * Returns: enum contents of @value
     687                 :             :  */
     688                 :             : gint
     689                 :       14143 : g_value_get_enum (const GValue *value)
     690                 :             : {
     691                 :       14143 :   g_return_val_if_fail (G_VALUE_HOLDS_ENUM (value), 0);
     692                 :             :   
     693                 :       14143 :   return value->data[0].v_long;
     694                 :             : }
     695                 :             : 
     696                 :             : /**
     697                 :             :  * g_value_set_flags:
     698                 :             :  * @value: a valid #GValue whose type is derived from %G_TYPE_FLAGS
     699                 :             :  * @v_flags: flags value to be set
     700                 :             :  *
     701                 :             :  * Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.
     702                 :             :  */
     703                 :             : void
     704                 :        6974 : g_value_set_flags (GValue *value,
     705                 :             :                    guint   v_flags)
     706                 :             : {
     707                 :        6974 :   g_return_if_fail (G_VALUE_HOLDS_FLAGS (value));
     708                 :             :   
     709                 :        6974 :   value->data[0].v_ulong = v_flags;
     710                 :             : }
     711                 :             : 
     712                 :             : /**
     713                 :             :  * g_value_get_flags:
     714                 :             :  * @value: a valid #GValue whose type is derived from %G_TYPE_FLAGS
     715                 :             :  *
     716                 :             :  * Get the contents of a %G_TYPE_FLAGS #GValue.
     717                 :             :  *
     718                 :             :  * Returns: flags contents of @value
     719                 :             :  */
     720                 :             : guint
     721                 :        4797 : g_value_get_flags (const GValue *value)
     722                 :             : {
     723                 :        4797 :   g_return_val_if_fail (G_VALUE_HOLDS_FLAGS (value), 0);
     724                 :             :   
     725                 :        4797 :   return value->data[0].v_ulong;
     726                 :             : }
        

Generated by: LCOV version 2.0-1