src/core/fma-boxed.c

   1 /*
   2  * FileManager-Actions
   3  * A file-manager extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006-2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009-2015 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * FileManager-Actions is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * FileManager-Actions is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with FileManager-Actions; see the file COPYING. If not, see
  21  * <http://www.gnu.org/licenses/>.
  22  *
  23  * Authors:
  24  *   Frederic Ruaudel <grumz@grumz.net>
  25  *   Rodrigo Moya <rodrigo@gnome-db.org>
  26  *   Pierre Wieser <pwieser@trychlos.org>
  27  *   ... and many others (see AUTHORS)
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include <api/fma-boxed.h>
  38 #include <api/fma-data-types.h>
  39 #include <api/fma-core-utils.h>
  40
  41 /* private class data
  42  */
  43 struct _FMABoxedClassPrivate {
  44         void *empty;                                            /* so that gcc -pedantic is happy */
  45 };
  46
  47 /* sBoxedDef:
  48  * This is the structure which fully defines the behavior of this data type.
  49  */
  50 typedef struct {
  51         guint            type;
  52         const gchar     *label;
  53         gboolean      ( *are_equal )     ( const FMABoxed *, const FMABoxed * );
  54         void          ( *copy )          ( FMABoxed *, const FMABoxed * );
  55         void          ( *free )          ( FMABoxed * );
  56         void          ( *from_string )   ( FMABoxed *, const gchar * );
  57         void          ( *from_value )    ( FMABoxed *, const GValue * );
  58         void          ( *from_void )     ( FMABoxed *, const void * );
  59         gboolean      ( *to_bool )       ( const FMABoxed * );
  60         gconstpointer ( *to_pointer )    ( const FMABoxed * );
  61         gchar       * ( *to_string )     ( const FMABoxed * );
  62         GSList      * ( *to_string_list )( const FMABoxed * );
  63         guint         ( *to_uint )       ( const FMABoxed * );
  64         GList       * ( *to_uint_list )  ( const FMABoxed * );
  65         void          ( *to_value )      ( const FMABoxed *, GValue * );
  66         void        * ( *to_void )       ( const FMABoxed * );
  67 }
  68         sBoxedDef;
  69
  70 /* private instance data
  71  */
  72 struct _FMABoxedPrivate {
  73         gboolean         dispose_has_run;
  74         const sBoxedDef *def;
  75         gboolean         is_set;
  76         union {
  77                 gboolean  boolean;
  78                 void     *pointer;
  79                 gchar    *string;
  80                 GSList   *string_list;
  81                 guint     uint;
  82                 GList    *uint_list;
  83         } u;
  84 };
  85
  86 #define LIST_SEPARATOR                                  ";"
  87 #define DEBUG                                                   if( 0 ) g_debug
  88
  89 static GObjectClass *st_parent_class    = NULL;
  90
  91 static GType            register_type( void );
  92 static void             class_init( FMABoxedClass *klass );
  93 static void             instance_init( GTypeInstance *instance, gpointer klass );
  94 static void             instance_dispose( GObject *object );
  95 static void             instance_finalize( GObject *object );
  96
  97 static FMABoxed        *boxed_new( const sBoxedDef *def );
  98 static const sBoxedDef *get_boxed_def( guint type );
  99 static gchar          **string_to_array( const gchar *string );
 100
 101 static gboolean         bool_are_equal( const FMABoxed *a, const FMABoxed *b );
 102 static void             bool_copy( FMABoxed *dest, const FMABoxed *src );
 103 static void             bool_free( FMABoxed *boxed );
 104 static void             bool_from_string( FMABoxed *boxed, const gchar *string );
 105 static void             bool_from_value( FMABoxed *boxed, const GValue *value );
 106 static void             bool_from_void( FMABoxed *boxed, const void *value );
 107 static gchar           *bool_to_string( const FMABoxed *boxed );
 108 static gboolean         bool_to_bool( const FMABoxed *boxed );
 109 static gconstpointer    bool_to_pointer( const FMABoxed *boxed );
 110 static gchar           *bool_to_string( const FMABoxed *boxed );
 111 static void             bool_to_value( const FMABoxed *boxed, GValue *value );
 112 static void            *bool_to_void( const FMABoxed *boxed );
 113
 114 static gboolean         pointer_are_equal( const FMABoxed *a, const FMABoxed *b );
 115 static void             pointer_copy( FMABoxed *dest, const FMABoxed *src );
 116 static void             pointer_free( FMABoxed *boxed );
 117 static void             pointer_from_string( FMABoxed *boxed, const gchar *string );
 118 static void             pointer_from_value( FMABoxed *boxed, const GValue *value );
 119 static void             pointer_from_void( FMABoxed *boxed, const void *value );
 120 static gconstpointer    pointer_to_pointer( const FMABoxed *boxed );
 121 static gchar           *pointer_to_string( const FMABoxed *boxed );
 122 static void             pointer_to_value( const FMABoxed *boxed, GValue *value );
 123 static void            *pointer_to_void( const FMABoxed *boxed );
 124
 125 static gboolean         string_are_equal( const FMABoxed *a, const FMABoxed *b );
 126 static void             string_copy( FMABoxed *dest, const FMABoxed *src );
 127 static void             string_free( FMABoxed *boxed );
 128 static void             string_from_string( FMABoxed *boxed, const gchar *string );
 129 static void             string_from_value( FMABoxed *boxed, const GValue *value );
 130 static void             string_from_void( FMABoxed *boxed, const void *value );
 131 static gconstpointer    string_to_pointer( const FMABoxed *boxed );
 132 static gchar           *string_to_string( const FMABoxed *boxed );
 133 static void             string_to_value( const FMABoxed *boxed, GValue *value );
 134 static void            *string_to_void( const FMABoxed *boxed );
 135
 136 static gboolean         string_list_are_equal( const FMABoxed *a, const FMABoxed *b );
 137 static void             string_list_copy( FMABoxed *dest, const FMABoxed *src );
 138 static void             string_list_free( FMABoxed *boxed );
 139 static void             string_list_from_string( FMABoxed *boxed, const gchar *string );
 140 static void             string_list_from_value( FMABoxed *boxed, const GValue *value );
 141 static void             string_list_from_void( FMABoxed *boxed, const void *value );
 142 static gconstpointer    string_list_to_pointer( const FMABoxed *boxed );
 143 static gchar           *string_list_to_string( const FMABoxed *boxed );
 144 static GSList          *string_list_to_string_list( const FMABoxed *boxed );
 145 static void             string_list_to_value( const FMABoxed *boxed, GValue *value );
 146 static void            *string_list_to_void( const FMABoxed *boxed );
 147
 148 static gboolean         locale_are_equal( const FMABoxed *a, const FMABoxed *b );
 149
 150 static gboolean         uint_are_equal( const FMABoxed *a, const FMABoxed *b );
 151 static void             uint_copy( FMABoxed *dest, const FMABoxed *src );
 152 static void             uint_free( FMABoxed *boxed );
 153 static void             uint_from_string( FMABoxed *boxed, const gchar *string );
 154 static void             uint_from_value( FMABoxed *boxed, const GValue *value );
 155 static void             uint_from_void( FMABoxed *boxed, const void *value );
 156 static gconstpointer    uint_to_pointer( const FMABoxed *boxed );
 157 static gchar           *uint_to_string( const FMABoxed *boxed );
 158 static guint            uint_to_uint( const FMABoxed *boxed );
 159 static void             uint_to_value( const FMABoxed *boxed, GValue *value );
 160 static void            *uint_to_void( const FMABoxed *boxed );
 161
 162 static gboolean         uint_list_are_equal( const FMABoxed *a, const FMABoxed *b );
 163 static void             uint_list_copy( FMABoxed *dest, const FMABoxed *src );
 164 static void             uint_list_free( FMABoxed *boxed );
 165 static void             uint_list_from_string( FMABoxed *boxed, const gchar *string );
 166 static void             uint_list_from_value( FMABoxed *boxed, const GValue *value );
 167 static void             uint_list_from_void( FMABoxed *boxed, const void *value );
 168 static gconstpointer    uint_list_to_pointer( const FMABoxed *boxed );
 169 static gchar           *uint_list_to_string( const FMABoxed *boxed );
 170 static GList           *uint_list_to_uint_list( const FMABoxed *boxed );
 171 static void             uint_list_to_value( const FMABoxed *boxed, GValue *value );
 172 static void            *uint_list_to_void( const FMABoxed *boxed );
 173
 174 static sBoxedDef st_boxed_def[] = {
 175                 { FMA_DATA_TYPE_BOOLEAN,
 176                                 "boolean",
 177                                 bool_are_equal,
 178                                 bool_copy,
 179                                 bool_free,
 180                                 bool_from_string,
 181                                 bool_from_value,
 182                                 bool_from_void,
 183                                 bool_to_bool,
 184                                 bool_to_pointer,
 185                                 bool_to_string,
 186                                 NULL,
 187                                 NULL,
 188                                 NULL,
 189                                 bool_to_value,
 190                                 bool_to_void
 191                                 },
 192                 { FMA_DATA_TYPE_POINTER,
 193                                 "pointer",
 194                                 pointer_are_equal,
 195                                 pointer_copy,
 196                                 pointer_free,
 197                                 pointer_from_string,
 198                                 pointer_from_value,
 199                                 pointer_from_void,
 200                                 NULL,
 201                                 pointer_to_pointer,
 202                                 pointer_to_string,
 203                                 NULL,
 204                                 NULL,
 205                                 NULL,
 206                                 pointer_to_value,
 207                                 pointer_to_void
 208                                 },
 209                 { FMA_DATA_TYPE_STRING,
 210                                 "string",
 211                                 string_are_equal,
 212                                 string_copy,
 213                                 string_free,
 214                                 string_from_string,
 215                                 string_from_value,
 216                                 string_from_void,
 217                                 NULL,                                           /* to_bool */
 218                                 string_to_pointer,
 219                                 string_to_string,
 220                                 NULL,                                           /* to_string_list */
 221                                 NULL,                                           /* to_uint */
 222                                 NULL,                                           /* to_uint_list */
 223                                 string_to_value,
 224                                 string_to_void
 225                                 },
 226                 { FMA_DATA_TYPE_STRING_LIST,
 227                                 "string_list",
 228                                 string_list_are_equal,
 229                                 string_list_copy,
 230                                 string_list_free,
 231                                 string_list_from_string,
 232                                 string_list_from_value,
 233                                 string_list_from_void,
 234                                 NULL,
 235                                 string_list_to_pointer,
 236                                 string_list_to_string,
 237                                 string_list_to_string_list,
 238                                 NULL,
 239                                 NULL,
 240                                 string_list_to_value,
 241                                 string_list_to_void
 242                                 },
 243                 { FMA_DATA_TYPE_LOCALE_STRING,
 244                                 "locale_string",
 245                                 locale_are_equal,
 246                                 string_copy,
 247                                 string_free,
 248                                 string_from_string,
 249                                 string_from_value,
 250                                 string_from_void,
 251                                 NULL,                                           /* to_bool */
 252                                 string_to_pointer,
 253                                 string_to_string,
 254                                 NULL,                                           /* to_string_list */
 255                                 NULL,                                           /* to_uint */
 256                                 NULL,                                           /* to_uint_list */
 257                                 string_to_value,
 258                                 string_to_void
 259                                 },
 260                 { FMA_DATA_TYPE_UINT,
 261                                 "uint",
 262                                 uint_are_equal,
 263                                 uint_copy,
 264                                 uint_free,
 265                                 uint_from_string,
 266                                 uint_from_value,
 267                                 uint_from_void,
 268                                 NULL,
 269                                 uint_to_pointer,
 270                                 uint_to_string,
 271                                 NULL,
 272                                 uint_to_uint,
 273                                 NULL,
 274                                 uint_to_value,
 275                                 uint_to_void
 276                                 },
 277                 { FMA_DATA_TYPE_UINT_LIST,
 278                                 "uint_list",
 279                                 uint_list_are_equal,
 280                                 uint_list_copy,
 281                                 uint_list_free,
 282                                 uint_list_from_string,
 283                                 uint_list_from_value,
 284                                 uint_list_from_void,
 285                                 NULL,
 286                                 uint_list_to_pointer,
 287                                 uint_list_to_string,
 288                                 NULL,
 289                                 NULL,
 290                                 uint_list_to_uint_list,
 291                                 uint_list_to_value,
 292                                 uint_list_to_void
 293                                 },
 294                 { 0 }
 295 };
 296
 297 GType
 298 fma_boxed_get_type( void )
 299 {
 300         static GType item_type = 0;
 301
 302         if( item_type == 0 ){
 303                 item_type = register_type();
 304         }
 305
 306         return( item_type );
 307 }
 308
 309 static GType
 310 register_type( void )
 311 {
 312         static const gchar *thisfn = "fma_boxed_register_type";
 313         GType type;
 314
 315         static GTypeInfo info = {
 316                 sizeof( FMABoxedClass ),
 317                 NULL,
 318                 NULL,
 319                 ( GClassInitFunc ) class_init,
 320                 NULL,
 321                 NULL,
 322                 sizeof( FMABoxed ),
 323                 0,
 324                 ( GInstanceInitFunc ) instance_init
 325         };
 326
 327         g_debug( "%s", thisfn );
 328
 329         type = g_type_register_static( G_TYPE_OBJECT, "FMABoxed", &info, 0 );
 330
 331         return( type );
 332 }
 333
 334 static void
 335 class_init( FMABoxedClass *klass )
 336 {
 337         static const gchar *thisfn = "fma_boxed_class_init";
 338         GObjectClass *object_class;
 339
 340         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 341
 342         st_parent_class = g_type_class_peek_parent( klass );
 343
 344         object_class = G_OBJECT_CLASS( klass );
 345         object_class->dispose = instance_dispose;
 346         object_class->finalize = instance_finalize;
 347
 348         klass->private = g_new0( FMABoxedClassPrivate, 1 );
 349 }
 350
 351 static void
 352 instance_init( GTypeInstance *instance, gpointer klass )
 353 {
 354         static const gchar *thisfn = "fma_boxed_instance_init";
 355         FMABoxed *self;
 356
 357         g_return_if_fail( FMA_IS_BOXED( instance ));
 358
 359         DEBUG( "%s: instance=%p (%s), klass=%p",
 360                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 361
 362         self = FMA_BOXED( instance );
 363
 364         self->private = g_new0( FMABoxedPrivate, 1 );
 365
 366         self->private->dispose_has_run = FALSE;
 367         self->private->def = NULL;
 368         self->private->is_set = FALSE;
 369 }
 370
 371 static void
 372 instance_dispose( GObject *object )
 373 {
 374         FMABoxed *self;
 375
 376         g_return_if_fail( FMA_IS_BOXED( object ));
 377
 378         self = FMA_BOXED( object );
 379
 380         if( !self->private->dispose_has_run ){
 381
 382                 self->private->dispose_has_run = TRUE;
 383
 384                 /* chain up to the parent class */
 385                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 386                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 387                 }
 388         }
 389 }
 390
 391 static void
 392 instance_finalize( GObject *object )
 393 {
 394         static const gchar *thisfn = "fma_boxed_instance_finalize";
 395         FMABoxed *self;
 396
 397         g_return_if_fail( FMA_IS_BOXED( object ));
 398
 399         DEBUG( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 400
 401         self = FMA_BOXED( object );
 402
 403         if( self->private->def ){
 404                 if( self->private->def->free ){
 405                         ( *self->private->def->free )( self );
 406                 }
 407         }
 408
 409         g_free( self->private );
 410
 411         /* chain call to parent class */
 412         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 413                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 414         }
 415 }
 416
 417 static FMABoxed *
 418 boxed_new( const sBoxedDef *def )
 419 {
 420         FMABoxed *boxed;
 421
 422         boxed = g_object_new( FMA_TYPE_BOXED, NULL );
 423         boxed->private->def = def;
 424
 425         return( boxed );
 426 }
 427
 428 static const sBoxedDef *
 429 get_boxed_def( guint type )
 430 {
 431         static const gchar *thisfn = "fma_boxed_get_boxed_def";
 432         sBoxedDef *def;
 433
 434         for( def = st_boxed_def ; def->type ; ++def ){
 435                 if( def->type == type ){
 436                         return(( const sBoxedDef * ) def );
 437                 }
 438         }
 439
 440         g_warning( "%s: unmanaged data type: %d", thisfn, type );
 441         return( NULL );
 442 }
 443
 444 /*
 445  * converts a string to an array of strings
 446  * accepts both:
 447  * - a semi-comma-separated list of strings (the last separator, if any, is not counted)
 448  * - a comma-separated list of strings between square brackets (à la GConf)
 449  *
 450  */
 451 static gchar **
 452 string_to_array( const gchar *string )
 453 {
 454         gchar *sdup;
 455         gchar **array;
 456
 457         array = NULL;
 458
 459         if( string && strlen( string )){
 460                 sdup = g_strstrip( g_strdup( string ));
 461
 462                 /* GConf-style string list [value,value]
 463                  */
 464                 if( sdup[0] == '[' && sdup[strlen(sdup)-1] == ']' ){
 465                         sdup[0] = ' ';
 466                         sdup[strlen(sdup)-1] = ' ';
 467                         sdup = g_strstrip( sdup );
 468                         array = g_strsplit( sdup, ",", -1 );
 469
 470                 /* semi-comma-separated list of strings
 471                  */
 472                 } else {
 473                         if( g_str_has_suffix( string, LIST_SEPARATOR )){
 474                                 sdup[strlen(sdup)-1] = ' ';
 475                                 sdup = g_strstrip( sdup );
 476                         }
 477                         array = g_strsplit( sdup, LIST_SEPARATOR, -1 );
 478                 }
 479                 g_free( sdup );
 480         }
 481
 482         return( array );
 483 }
 484
 485 /**
 486  * fma_boxed_set_type:
 487  * @boxed: this #FMABoxed object.
 488  * @type: the required type as defined in fma-data-types.h
 489  *
 490  * Set the type of the just-allocated @boxed object.
 491  *
 492  * Since: 3.1
 493  */
 494 void
 495 fma_boxed_set_type( FMABoxed *boxed, guint type )
 496 {
 497         g_return_if_fail( FMA_IS_BOXED( boxed ));
 498         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 499         g_return_if_fail( boxed->private->def == NULL );
 500
 501         boxed->private->def = get_boxed_def( type );
 502 }
 503
 504 /**
 505  * fma_boxed_are_equal:
 506  * @a: the first #FMABoxed object.
 507  * @b: the second #FMABoxed object.
 508  *
 509  * Returns: %TRUE if @a and @b are equal, %FALSE else.
 510  *
 511  * Since: 3.1
 512  */
 513 gboolean
 514 fma_boxed_are_equal( const FMABoxed *a, const FMABoxed *b )
 515 {
 516         gboolean are_equal;
 517
 518         g_return_val_if_fail( FMA_IS_BOXED( a ), FALSE );
 519         g_return_val_if_fail( a->private->dispose_has_run == FALSE, FALSE );
 520         g_return_val_if_fail( FMA_IS_BOXED( b ), FALSE );
 521         g_return_val_if_fail( b->private->dispose_has_run == FALSE, FALSE );
 522         g_return_val_if_fail( a->private->def, FALSE );
 523         g_return_val_if_fail( a->private->def == b->private->def, FALSE );
 524         g_return_val_if_fail( a->private->def->are_equal, FALSE );
 525
 526         are_equal = FALSE;
 527
 528         if( a->private->is_set == b->private->is_set ){
 529                 are_equal = TRUE;
 530                 if( a->private->is_set ){
 531                         are_equal = ( *a->private->def->are_equal )( a, b );
 532                 }
 533         }
 534
 535         return( are_equal );
 536 }
 537
 538 /**
 539  * fma_boxed_copy:
 540  * @boxed: the source #FMABoxed box.
 541  *
 542  * Returns: a copy of @boxed, as a newly allocated #FMABoxed which should
 543  * be g_object_unref() by the caller.
 544  *
 545  * Since: 3.1
 546  */
 547 FMABoxed *
 548 fma_boxed_copy( const FMABoxed *boxed )
 549 {
 550         FMABoxed *dest;
 551
 552         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 553         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 554         g_return_val_if_fail( boxed->private->def, NULL );
 555         g_return_val_if_fail( boxed->private->def->copy, NULL );
 556
 557         dest = boxed_new( boxed->private->def );
 558         if( boxed->private->is_set ){
 559                 ( *boxed->private->def->copy )( dest, boxed );
 560                 dest->private->is_set = TRUE;
 561         }
 562
 563         return( dest );
 564 }
 565
 566 /**
 567  * fma_boxed_dump:
 568  * @boxed: the #FMABoxed box to be dumped.
 569  *
 570  * Dumps the @boxed box.
 571  *
 572  * Since: 3.1
 573  */
 574 void
 575 fma_boxed_dump( const FMABoxed *boxed )
 576 {
 577         static const gchar *thisfn = "fma_boxed_dump";
 578         gchar *str;
 579
 580         g_return_if_fail( FMA_IS_BOXED( boxed ));
 581         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 582         g_return_if_fail( boxed->private->def );
 583         g_return_if_fail( boxed->private->def->to_string );
 584
 585         str = ( boxed->private->is_set ) ? ( *boxed->private->def->to_string )( boxed ) : NULL;
 586         g_debug( "%s: boxed=%p, type=%u, is_set=%s, value=%s",
 587                         thisfn, ( void * ) boxed, boxed->private->def->type,
 588                         boxed->private->is_set ? "True":"False", str );
 589         g_free( str );
 590 }
 591
 592 /**
 593  * fma_boxed_new_from_string:
 594  * @type: the type of the #FMABoxed to be allocated.
 595  * @string: the initial value of the #FMABoxed as a string.
 596  *
 597  * Allocates a new #FMABoxed of the specified @type, and initializes it
 598  * with @string.
 599  *
 600  * If the type is a list, then the last separator is automatically stripped.
 601  *
 602  * Returns: a newly allocated #FMABoxed, which should be g_object_unref()
 603  * by the caller, or %NULL if the type is unknowned, or does not provide
 604  * the 'from_string' function.
 605  *
 606  * Since: 3.1
 607  */
 608 FMABoxed *
 609 fma_boxed_new_from_string( guint type, const gchar *string )
 610 {
 611         const sBoxedDef *def;
 612         FMABoxed *boxed;
 613
 614         def = get_boxed_def( type );
 615
 616         g_return_val_if_fail( def, NULL );
 617         g_return_val_if_fail( def->from_string, NULL );
 618
 619         boxed = boxed_new( def );
 620         ( *def->from_string )( boxed, string );
 621         boxed->private->is_set = TRUE;
 622
 623         return( boxed );
 624 }
 625
 626 /**
 627  * fma_boxed_get_boolean:
 628  * @boxed: the #FMABoxed structure.
 629  *
 630  * Returns: the boolean value if @boxed is of %FMA_DATA_TYPE_BOOLEAN type,
 631  * %FALSE else.
 632  *
 633  * Since: 3.1
 634  */
 635 gboolean
 636 fma_boxed_get_boolean( const FMABoxed *boxed )
 637 {
 638         gboolean value;
 639
 640         g_return_val_if_fail( FMA_IS_BOXED( boxed ), FALSE );
 641         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, FALSE );
 642         g_return_val_if_fail( boxed->private->def, FALSE );
 643         g_return_val_if_fail( boxed->private->def->type == FMA_DATA_TYPE_BOOLEAN, FALSE );
 644         g_return_val_if_fail( boxed->private->def->to_bool, FALSE );
 645
 646         value = ( *boxed->private->def->to_bool )( boxed );
 647
 648         return( value );
 649 }
 650
 651 /**
 652  * fma_boxed_get_pointer:
 653  * @boxed: the #FMABoxed structure.
 654  *
 655  * Returns: a const pointer to the data if @boxed is of %FMA_DATA_TYPE_POINTER
 656  * type, %NULL else.
 657  *
 658  * Since: 3.1
 659  */
 660 gconstpointer
 661 fma_boxed_get_pointer( const FMABoxed *boxed )
 662 {
 663         gconstpointer value;
 664
 665         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 666         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 667         g_return_val_if_fail( boxed->private->def, NULL );
 668         g_return_val_if_fail( boxed->private->def->to_pointer, NULL );
 669
 670         value = ( *boxed->private->def->to_pointer )( boxed );
 671
 672         return( value );
 673 }
 674
 675 /**
 676  * fma_boxed_get_string:
 677  * @boxed: the #FMABoxed structure.
 678  *
 679  * Returns: a newly allocated string if @boxed is of %FMA_DATA_TYPE_STRING
 680  * type, which should be g_free() by the caller, %NULL else.
 681  *
 682  * Since: 3.1
 683  */
 684 gchar *
 685 fma_boxed_get_string( const FMABoxed *boxed )
 686 {
 687         gchar *value;
 688
 689         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 690         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 691         g_return_val_if_fail( boxed->private->def, NULL );
 692         g_return_val_if_fail( boxed->private->def->to_string, NULL );
 693
 694         value = ( *boxed->private->def->to_string )( boxed );
 695
 696         return( value );
 697 }
 698
 699 /**
 700  * fma_boxed_get_string_list:
 701  * @boxed: the #FMABoxed structure.
 702  *
 703  * Returns: a newly allocated string list if @boxed is of %FMA_DATA_TYPE_STRING_LIST
 704  * type, which should be fma_core_utils_slist_free() by the caller, %NULL else.
 705  *
 706  * Since: 3.1
 707  */
 708 GSList *
 709 fma_boxed_get_string_list( const FMABoxed *boxed )
 710 {
 711         GSList *value;
 712
 713         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 714         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 715         g_return_val_if_fail( boxed->private->def, NULL );
 716         g_return_val_if_fail( boxed->private->def->type == FMA_DATA_TYPE_STRING_LIST, NULL );
 717         g_return_val_if_fail( boxed->private->def->to_string_list, NULL );
 718
 719         value = ( *boxed->private->def->to_string_list )( boxed );
 720
 721         return( value );
 722 }
 723
 724 /**
 725  * fma_boxed_get_uint:
 726  * @boxed: the #FMABoxed structure.
 727  *
 728  * Returns: an unsigned integer if @boxed is of %FMA_DATA_TYPE_UINT type,
 729  * zero else.
 730  *
 731  * Since: 3.1
 732  */
 733 guint
 734 fma_boxed_get_uint( const FMABoxed *boxed )
 735 {
 736         guint value;
 737
 738         g_return_val_if_fail( FMA_IS_BOXED( boxed ), 0 );
 739         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, 0 );
 740         g_return_val_if_fail( boxed->private->def, 0 );
 741         g_return_val_if_fail( boxed->private->def->type == FMA_DATA_TYPE_UINT, 0 );
 742         g_return_val_if_fail( boxed->private->def->to_uint, 0 );
 743
 744         value = ( *boxed->private->def->to_uint )( boxed );
 745
 746         return( value );
 747 }
 748
 749 /**
 750  * fma_boxed_get_uint_list:
 751  * @boxed: the #FMABoxed structure.
 752  *
 753  * Returns: a newly allocated list if @boxed is of %FMA_DATA_TYPE_UINT_LIST
 754  * type, which should be g_list_free() by the caller, %FALSE else.
 755  *
 756  * Since: 3.1
 757  */
 758 GList *
 759 fma_boxed_get_uint_list( const FMABoxed *boxed )
 760 {
 761         GList *value;
 762
 763         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 764         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 765         g_return_val_if_fail( boxed->private->def, NULL );
 766         g_return_val_if_fail( boxed->private->def->type == FMA_DATA_TYPE_UINT_LIST, NULL );
 767         g_return_val_if_fail( boxed->private->def->to_uint_list, NULL );
 768
 769         value = ( *boxed->private->def->to_uint_list )( boxed );
 770
 771         return( value );
 772 }
 773
 774 /**
 775  * fma_boxed_get_as_value:
 776  * @boxed: the #FMABoxed whose value is to be got.
 777  * @value: the #GValue which holds the string to be set.
 778  *
 779  * Setup @value with the content of the @boxed.
 780  *
 781  * Since: 3.1
 782  */
 783 void
 784 fma_boxed_get_as_value( const FMABoxed *boxed, GValue *value )
 785 {
 786         g_return_if_fail( FMA_IS_BOXED( boxed ));
 787         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 788         g_return_if_fail( boxed->private->def );
 789         g_return_if_fail( boxed->private->def->to_value );
 790
 791         ( *boxed->private->def->to_value )( boxed, value );
 792 }
 793
 794 /**
 795  * fma_boxed_get_as_void:
 796  * @boxed: the #FMABoxed whose value is to be got.
 797  *
 798  * Returns: the content of the @boxed.
 799  *
 800  * If of type FMA_DATA_TYPE_STRING (resp. FMA_DATA_TYPE_LOCALE_STRING,
 801  * FMA_DATA_TYPE_STRING_LIST or FMA_DATA_TYPE_UINT_LIST), then the content
 802  * is returned in a newly allocated value, which should be g_free() (resp.
 803  * g_free(), fma_core_utils_slist_free(), g_list_free()) by the caller.
 804  *
 805  * Since: 3.1
 806  */
 807 void *
 808 fma_boxed_get_as_void( const FMABoxed *boxed )
 809 {
 810         g_return_val_if_fail( FMA_IS_BOXED( boxed ), NULL );
 811         g_return_val_if_fail( boxed->private->dispose_has_run == FALSE, NULL );
 812         g_return_val_if_fail( boxed->private->def, NULL );
 813         g_return_val_if_fail( boxed->private->def->to_void, NULL );
 814
 815         return(( *boxed->private->def->to_void )( boxed ));
 816 }
 817
 818 /**
 819  * fma_boxed_set_from_boxed:
 820  * @boxed: the #FMABoxed whose value is to be set.
 821  * @value: the source #FMABoxed.
 822  *
 823  * Copy value from @value to @boxed.
 824  *
 825  * Since: 3.1
 826  */
 827 void
 828 fma_boxed_set_from_boxed( FMABoxed *boxed, const FMABoxed *value )
 829 {
 830         g_return_if_fail( FMA_IS_BOXED( boxed ));
 831         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 832         g_return_if_fail( FMA_IS_BOXED( value ));
 833         g_return_if_fail( value->private->dispose_has_run == FALSE );
 834         g_return_if_fail( boxed->private->def );
 835         g_return_if_fail( boxed->private->def == value->private->def );
 836         g_return_if_fail( boxed->private->def->copy );
 837         g_return_if_fail( boxed->private->def->free );
 838
 839         ( *boxed->private->def->free )( boxed );
 840         ( *boxed->private->def->copy )( boxed, value );
 841         boxed->private->is_set = TRUE;
 842 }
 843
 844 /**
 845  * fma_boxed_set_from_string:
 846  * @boxed: the #FMABoxed whose value is to be set.
 847  * @value: the string to be set.
 848  *
 849  * Evaluates the @value and set it to the @boxed.
 850  *
 851  * Since: 3.1
 852  */
 853 void
 854 fma_boxed_set_from_string( FMABoxed *boxed, const gchar *value )
 855 {
 856         g_return_if_fail( FMA_IS_BOXED( boxed ));
 857         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 858         g_return_if_fail( boxed->private->def );
 859         g_return_if_fail( boxed->private->def->free );
 860         g_return_if_fail( boxed->private->def->from_string );
 861
 862         ( *boxed->private->def->free )( boxed );
 863         ( *boxed->private->def->from_string )( boxed, value );
 864         boxed->private->is_set = TRUE;
 865 }
 866
 867 /**
 868  * fma_boxed_set_from_value:
 869  * @boxed: the #FMABoxed whose value is to be set.
 870  * @value: the value whose content is to be got.
 871  *
 872  * Evaluates the @value and set it to the @boxed.
 873  *
 874  * Since: 3.1
 875  */
 876 void
 877 fma_boxed_set_from_value( FMABoxed *boxed, const GValue *value )
 878 {
 879         g_return_if_fail( FMA_IS_BOXED( boxed ));
 880         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 881         g_return_if_fail( boxed->private->def );
 882         g_return_if_fail( boxed->private->def->free );
 883         g_return_if_fail( boxed->private->def->from_value );
 884
 885         ( *boxed->private->def->free )( boxed );
 886         ( *boxed->private->def->from_value )( boxed, value );
 887         boxed->private->is_set = TRUE;
 888 }
 889
 890 /**
 891  * fma_boxed_set_from_void:
 892  * @boxed: the #FMABoxed whose value is to be set.
 893  * @value: the value whose content is to be got.
 894  *
 895  * Evaluates the @value and set it to the @boxed.
 896  *
 897  * Since: 3.1
 898  */
 899 void
 900 fma_boxed_set_from_void( FMABoxed *boxed, const void *value )
 901 {
 902         g_return_if_fail( FMA_IS_BOXED( boxed ));
 903         g_return_if_fail( boxed->private->dispose_has_run == FALSE );
 904         g_return_if_fail( boxed->private->def );
 905         g_return_if_fail( boxed->private->def->free );
 906         g_return_if_fail( boxed->private->def->from_void );
 907
 908         ( *boxed->private->def->free )( boxed );
 909         ( *boxed->private->def->from_void )( boxed, value );
 910         boxed->private->is_set = TRUE;
 911 }
 912
 913 static gboolean
 914 bool_are_equal( const FMABoxed *a, const FMABoxed *b )
 915 {
 916         return( a->private->u.boolean == b->private->u.boolean );
 917 }
 918
 919 static void
 920 bool_copy( FMABoxed *dest, const FMABoxed *src )
 921 {
 922         dest->private->u.boolean = src->private->u.boolean;
 923 }
 924
 925 static void
 926 bool_free( FMABoxed *boxed )
 927 {
 928         boxed->private->u.boolean = FALSE;
 929         boxed->private->is_set = FALSE;
 930 }
 931
 932 static void
 933 bool_from_string( FMABoxed *boxed, const gchar *string )
 934 {
 935         boxed->private->u.boolean = fma_core_utils_boolean_from_string( string );
 936 }
 937
 938 static void
 939 bool_from_value( FMABoxed *boxed, const GValue *value )
 940 {
 941         boxed->private->u.boolean = g_value_get_boolean( value );
 942 }
 943
 944 static void
 945 bool_from_void( FMABoxed *boxed, const void *value )
 946 {
 947         boxed->private->u.boolean = GPOINTER_TO_UINT( value );
 948 }
 949
 950 static gboolean
 951 bool_to_bool( const FMABoxed *boxed )
 952 {
 953         return( boxed->private->u.boolean );
 954 }
 955
 956 static gconstpointer
 957 bool_to_pointer( const FMABoxed *boxed )
 958 {
 959         return(( gconstpointer ) GUINT_TO_POINTER( boxed->private->u.boolean ));
 960 }
 961
 962 static gchar *
 963 bool_to_string( const FMABoxed *boxed )
 964 {
 965         return( g_strdup_printf( "%s", boxed->private->u.boolean ? "true":"false" ));
 966 }
 967
 968 static void
 969 bool_to_value( const FMABoxed *boxed, GValue *value )
 970 {
 971         g_value_set_boolean( value, boxed->private->u.boolean );
 972 }
 973
 974 static void *
 975 bool_to_void( const FMABoxed *boxed )
 976 {
 977         return( GUINT_TO_POINTER( boxed->private->u.boolean ));
 978 }
 979
 980 static gboolean
 981 pointer_are_equal( const FMABoxed *a, const FMABoxed *b )
 982 {
 983         return( a->private->u.pointer == b->private->u.pointer );
 984 }
 985
 986 /*
 987  * note that copying a pointer is not safe
 988  */
 989 static void
 990 pointer_copy( FMABoxed *dest, const FMABoxed *src )
 991 {
 992         dest->private->u.pointer = src->private->u.pointer;
 993 }
 994
 995 static void
 996 pointer_free( FMABoxed *boxed )
 997 {
 998         boxed->private->u.pointer = NULL;
 999         boxed->private->is_set = FALSE;
1000 }
1001
1002 static void
1003 pointer_from_string( FMABoxed *boxed, const gchar *pointer )
1004 {
1005         g_warning( "fma_boxed_pointer_from_string: unrelevant function call" );
1006 }
1007
1008 static void
1009 pointer_from_value( FMABoxed *boxed, const GValue *value )
1010 {
1011         boxed->private->u.pointer = g_value_get_pointer( value );
1012 }
1013
1014 static void
1015 pointer_from_void( FMABoxed *boxed, const void *value )
1016 {
1017         boxed->private->u.pointer = ( void * ) value;
1018 }
1019
1020 static gconstpointer
1021 pointer_to_pointer( const FMABoxed *boxed )
1022 {
1023         return( boxed->private->u.pointer );
1024 }
1025
1026 static gchar *
1027 pointer_to_string( const FMABoxed *boxed )
1028 {
1029         return( g_strdup_printf( "%p", boxed->private->u.pointer ));
1030 }
1031
1032 static void
1033 pointer_to_value( const FMABoxed *boxed, GValue *value )
1034 {
1035         g_value_set_pointer( value, boxed->private->u.pointer );
1036 }
1037
1038 static void *
1039 pointer_to_void( const FMABoxed *boxed )
1040 {
1041         return( boxed->private->u.pointer );
1042 }
1043
1044 static gboolean
1045 string_are_equal( const FMABoxed *a, const FMABoxed *b )
1046 {
1047         if( a->private->u.string && b->private->u.string ){
1048                 return( strcmp( a->private->u.string, b->private->u.string ) == 0 );
1049         }
1050         if( !a->private->u.string && !b->private->u.string ){
1051                 return( TRUE );
1052         }
1053         return( FALSE );
1054 }
1055
1056 static void
1057 string_copy( FMABoxed *dest, const FMABoxed *src )
1058 {
1059         dest->private->u.string = g_strdup( src->private->u.string );
1060 }
1061
1062 static void
1063 string_free( FMABoxed *boxed )
1064 {
1065         g_free( boxed->private->u.string );
1066         boxed->private->u.string = NULL;
1067         boxed->private->is_set = FALSE;
1068 }
1069
1070 static void
1071 string_from_string( FMABoxed *boxed, const gchar *string )
1072 {
1073         boxed->private->u.string = g_strdup( string ? string : "" );
1074 }
1075
1076 static void
1077 string_from_value( FMABoxed *boxed, const GValue *value )
1078 {
1079         if( g_value_get_string( value )){
1080                 boxed->private->u.string = g_value_dup_string( value );
1081         } else {
1082                 boxed->private->u.string = g_strdup( "" );
1083         }
1084 }
1085
1086 static void
1087 string_from_void( FMABoxed *boxed, const void *value )
1088 {
1089         boxed->private->u.string = g_strdup( value ? ( const gchar * ) value : "" );
1090 }
1091
1092 static gconstpointer
1093 string_to_pointer( const FMABoxed *boxed )
1094 {
1095         return(( gconstpointer ) boxed->private->u.string );
1096 }
1097
1098 static gchar *
1099 string_to_string( const FMABoxed *boxed )
1100 {
1101         return( g_strdup( boxed->private->u.string ));
1102 }
1103
1104 static void
1105 string_to_value( const FMABoxed *boxed, GValue *value )
1106 {
1107         gchar *str;
1108
1109         str = string_to_string( boxed );
1110         g_value_set_string( value, str );
1111         g_free( str );
1112 }
1113
1114 static void *
1115 string_to_void( const FMABoxed *boxed )
1116 {
1117         return(( void * ) string_to_string( boxed ));
1118 }
1119
1120 /* the two string lists are equal if they have the same elements in the
1121  * same order
1122  */
1123 static gboolean
1124 string_list_are_equal( const FMABoxed *a, const FMABoxed *b )
1125 {
1126         GSList *ia, *ib;
1127         gboolean diff = FALSE;
1128
1129         guint na = g_slist_length( a->private->u.string_list );
1130         guint nb = g_slist_length( b->private->u.string_list );
1131
1132         if( na != nb ) return( FALSE );
1133
1134         for( ia=a->private->u.string_list, ib=b->private->u.string_list ; ia && ib && !diff ; ia=ia->next, ib=ib->next ){
1135                 if( strcmp( ia->data, ib->data ) != 0 ){
1136                         diff = TRUE;
1137                 }
1138         }
1139
1140         return( !diff );
1141 }
1142
1143 static void
1144 string_list_copy( FMABoxed *dest, const FMABoxed *src )
1145 {
1146         if( dest->private->is_set ){
1147                 string_list_free( dest );
1148         }
1149         dest->private->u.string_list = fma_core_utils_slist_duplicate( src->private->u.string_list );
1150         dest->private->is_set = TRUE;
1151 }
1152
1153 static void
1154 string_list_free( FMABoxed *boxed )
1155 {
1156         fma_core_utils_slist_free( boxed->private->u.string_list );
1157         boxed->private->u.string_list = NULL;
1158         boxed->private->is_set = FALSE;
1159 }
1160
1161 /*
1162  * accept string list both:
1163  * - as a semi-comma-separated list of strings
1164  * - as a comma-separated list of string, between two square brackets (à la GConf)
1165  */
1166 static void
1167 string_list_from_string( FMABoxed *boxed, const gchar *string )
1168 {
1169         gchar **array;
1170         gchar **i;
1171
1172         array = string_to_array( string );
1173
1174         if( array ){
1175                 i = ( gchar ** ) array;
1176                 while( *i ){
1177                         if( !fma_core_utils_slist_count( boxed->private->u.string_list, ( const gchar * )( *i ))){
1178                                 boxed->private->u.string_list = g_slist_prepend( boxed->private->u.string_list, g_strdup( *i ));
1179                         }
1180                         i++;
1181                 }
1182                 boxed->private->u.string_list = g_slist_reverse( boxed->private->u.string_list );
1183         }
1184
1185         g_strfreev( array );
1186 }
1187
1188 static void
1189 string_list_from_value( FMABoxed *boxed, const GValue *value )
1190 {
1191         string_list_from_void( boxed, ( const void * ) g_value_get_pointer( value ));
1192 }
1193
1194 static void
1195 string_list_from_void( FMABoxed *boxed, const void *value )
1196 {
1197         GSList *value_slist;
1198         GSList *it;
1199
1200         value_slist = ( GSList * ) value;
1201         for( it = value_slist ; it ; it = it->next ){
1202                 if( !fma_core_utils_slist_count( boxed->private->u.string_list, ( const gchar * ) it->data )){
1203                         boxed->private->u.string_list = g_slist_prepend( boxed->private->u.string_list, g_strdup(( const gchar * ) it->data ));
1204                 }
1205         }
1206         boxed->private->u.string_list = g_slist_reverse( boxed->private->u.string_list );
1207 }
1208
1209 static gconstpointer
1210 string_list_to_pointer( const FMABoxed *boxed )
1211 {
1212         return(( gconstpointer ) boxed->private->u.string_list );
1213 }
1214
1215 static gchar *
1216 string_list_to_string( const FMABoxed *boxed )
1217 {
1218         GSList *is;
1219         GString *str = g_string_new( "" );
1220         gboolean first;
1221
1222         first = TRUE;
1223         for( is = boxed->private->u.string_list ; is ; is = is->next ){
1224                 if( !first ){
1225                         str = g_string_append( str, LIST_SEPARATOR );
1226                 }
1227                 str = g_string_append( str, ( const gchar * ) is->data );
1228                 first = FALSE;
1229         }
1230
1231         return( g_string_free( str, FALSE ));
1232 }
1233
1234 static GSList *
1235 string_list_to_string_list( const FMABoxed *boxed )
1236 {
1237         return( fma_core_utils_slist_duplicate( boxed->private->u.string_list ));
1238 }
1239
1240 static void
1241 string_list_to_value( const FMABoxed *boxed, GValue *value )
1242 {
1243         g_value_set_pointer( value, fma_core_utils_slist_duplicate( boxed->private->u.string_list ));
1244 }
1245
1246 static void *
1247 string_list_to_void( const FMABoxed *boxed )
1248 {
1249         void *value = NULL;
1250
1251         if( boxed->private->u.string_list ){
1252                 value = fma_core_utils_slist_duplicate( boxed->private->u.string_list );
1253         }
1254
1255         return( value );
1256 }
1257
1258 static gboolean
1259 locale_are_equal( const FMABoxed *a, const FMABoxed *b )
1260 {
1261         if( !a->private->u.string && !b->private->u.string ){
1262                 return( TRUE );
1263         }
1264         if( !a->private->u.string || !b->private->u.string ){
1265                 return( FALSE );
1266         }
1267         return( fma_core_utils_str_collate( a->private->u.string, b->private->u.string ) == 0 );
1268 }
1269
1270 static gboolean
1271 uint_are_equal( const FMABoxed *a, const FMABoxed *b )
1272 {
1273         return( a->private->u.uint == b->private->u.uint );
1274 }
1275
1276 static void
1277 uint_copy( FMABoxed *dest, const FMABoxed *src )
1278 {
1279         dest->private->u.uint = src->private->u.uint;
1280         dest->private->is_set = TRUE;
1281 }
1282
1283 static void
1284 uint_free( FMABoxed *boxed )
1285 {
1286         boxed->private->u.uint = 0;
1287         boxed->private->is_set = FALSE;
1288 }
1289
1290 static void
1291 uint_from_string( FMABoxed *boxed, const gchar *string )
1292 {
1293         boxed->private->u.uint = string ? atoi( string ) : 0;
1294 }
1295
1296 static void
1297 uint_from_value( FMABoxed *boxed, const GValue *value )
1298 {
1299         boxed->private->u.uint = g_value_get_uint( value );
1300 }
1301
1302 static void
1303 uint_from_void( FMABoxed *boxed, const void *value )
1304 {
1305         boxed->private->u.uint = GPOINTER_TO_UINT( value );
1306 }
1307
1308 static gconstpointer
1309 uint_to_pointer( const FMABoxed *boxed )
1310 {
1311         return(( gconstpointer ) GUINT_TO_POINTER( boxed->private->u.uint ));
1312 }
1313
1314 static gchar *
1315 uint_to_string( const FMABoxed *boxed )
1316 {
1317         return( g_strdup_printf( "%u", boxed->private->u.uint ));
1318 }
1319
1320 static guint
1321 uint_to_uint( const FMABoxed *boxed )
1322 {
1323         return( boxed->private->u.uint );
1324 }
1325
1326 static void
1327 uint_to_value( const FMABoxed *boxed, GValue *value )
1328 {
1329         g_value_set_uint( value, boxed->private->u.uint );
1330 }
1331
1332 static void *
1333 uint_to_void( const FMABoxed *boxed )
1334 {
1335         return( GUINT_TO_POINTER( boxed->private->u.uint ));
1336 }
1337
1338 /* compare uint list as string list:
1339  * if the two list do not have the same count, then one is lesser than the other
1340  * if they have same count and same elements in same order, they are equal
1341  * else just arbitrarily return -1
1342  */
1343 static gboolean
1344 uint_list_are_equal( const FMABoxed *a, const FMABoxed *b )
1345 {
1346         GList *ia, *ib;
1347         gboolean diff = FALSE;
1348
1349         guint na = g_list_length( a->private->u.uint_list );
1350         guint nb = g_list_length( b->private->u.uint_list );
1351
1352         if( na != nb ) return( FALSE );
1353
1354         for( ia=a->private->u.uint_list, ib=b->private->u.uint_list ; ia && ib && !diff ; ia=ia->next, ib=ib->next ){
1355                 if( GPOINTER_TO_UINT( ia->data ) != GPOINTER_TO_UINT( ib->data )){
1356                         diff = TRUE;
1357                 }
1358         }
1359
1360         return( !diff );
1361 }
1362
1363 static void
1364 uint_list_copy( FMABoxed *dest, const FMABoxed *src )
1365 {
1366         GList *isrc;
1367
1368         dest->private->u.uint_list = NULL;
1369         for( isrc = src->private->u.uint_list ; isrc ; isrc = isrc->next ){
1370                 dest->private->u.uint_list = g_list_prepend( dest->private->u.uint_list, isrc->data );
1371         }
1372         dest->private->u.uint_list = g_list_reverse( dest->private->u.uint_list );
1373 }
1374
1375 static void
1376 uint_list_free( FMABoxed *boxed )
1377 {
1378         g_list_free( boxed->private->u.uint_list );
1379         boxed->private->u.uint_list = NULL;
1380         boxed->private->is_set = FALSE;
1381 }
1382
1383 static void
1384 uint_list_from_string( FMABoxed *boxed, const gchar *string )
1385 {
1386         gchar **array;
1387         gchar **i;
1388
1389         array = string_to_array( string );
1390
1391         if( array ){
1392                 i = ( gchar ** ) array;
1393                 while( *i ){
1394                         boxed->private->u.uint_list = g_list_prepend( boxed->private->u.uint_list, GINT_TO_POINTER( atoi( *i )));
1395                         i++;
1396                 }
1397                 boxed->private->u.uint_list = g_list_reverse( boxed->private->u.uint_list );
1398         } else {
1399                 boxed->private->u.uint_list = NULL;
1400         }
1401
1402         g_strfreev( array );
1403 }
1404
1405 static void
1406 uint_list_from_value( FMABoxed *boxed, const GValue *value )
1407 {
1408         if( g_value_get_pointer( value )){
1409                 boxed->private->u.uint_list = g_list_copy( g_value_get_pointer( value ));
1410         }
1411 }
1412
1413 static void
1414 uint_list_from_void( FMABoxed *boxed, const void *value )
1415 {
1416         if( value ){
1417                 boxed->private->u.uint_list = g_list_copy(( GList * ) value );
1418         }
1419 }
1420
1421 static gconstpointer
1422 uint_list_to_pointer( const FMABoxed *boxed )
1423 {
1424         return(( gconstpointer ) boxed->private->u.uint_list );
1425 }
1426
1427 static gchar *
1428 uint_list_to_string( const FMABoxed *boxed )
1429 {
1430         GList *is;
1431         GString *str = g_string_new( "" );
1432         gboolean first;
1433
1434         first = TRUE;
1435         for( is = boxed->private->u.uint_list ; is ; is = is->next ){
1436                 if( !first ){
1437                         str = g_string_append( str, LIST_SEPARATOR );
1438                 }
1439                 g_string_append_printf( str, "%u", GPOINTER_TO_UINT( is->data ));
1440                 first = FALSE;
1441         }
1442
1443         return( g_string_free( str, FALSE ));
1444 }
1445
1446 static GList *
1447 uint_list_to_uint_list( const FMABoxed *boxed )
1448 {
1449         return( g_list_copy( boxed->private->u.uint_list ));
1450 }
1451
1452 static void
1453 uint_list_to_value( const FMABoxed *boxed, GValue *value )
1454 {
1455         g_value_set_pointer( value, g_list_copy( boxed->private->u.uint_list ));
1456 }
1457
1458 static void *
1459 uint_list_to_void( const FMABoxed *boxed )
1460 {
1461         void *value = NULL;
1462
1463         if( boxed->private->u.uint_list ){
1464                 value = g_list_copy( boxed->private->u.uint_list );
1465         }
1466
1467         return( value );
1468 }