1 /* GLIB - Library of useful routines for C programming

     2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

     3  * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Lesser General Public

     7  * License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Lesser General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Lesser General Public

    16  * License along with this library; if not, write to the

    17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 

    21 /*

    22  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

    23  * file for a list of people on the GLib Team.  See the ChangeLog

    24  * files for a list of changes.  These files are distributed with

    25  * GLib at ftp://ftp.gtk.org/pub/gtk/. 

    26  */

    27 

    28 /* 

    29  * MT safe

    30  */

    31 

    32 #include "config.h"

    33 

    34 #include <string.h>

    35 #include <stdlib.h>

    36 

    37 #include "garray.h"

    38 

    39 #include "gmem.h"

    40 #include "gthread.h"

    41 #include "gmessages.h"

    42 #include "gqsort.h"

    43 

    44 #include "galias.h"

    45 

    46 #ifdef __SYMBIAN32__

    47 #include "glib.h"

    48 #include "glibbackend.h"

    49 #define g_mem_gc_friendly (*_g_mem_gc_friendly())

    50 #endif /* __SYMBIAN32__ */

    51 

    52 

    53 #define MIN_ARRAY_SIZE  16

    54 

    55 typedef struct _GRealArray  GRealArray;

    56 

    57 struct _GRealArray

    58 {

    59   guint8 *data;

    60   guint   len;

    61   guint   alloc;

    62   guint   elt_size;

    63   guint   zero_terminated : 1;

    64   guint   clear : 1;

    65 };

    66 

    67 #define g_array_elt_len(array,i) ((array)->elt_size * (i))

    68 #define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i)))

    69 #define g_array_elt_zero(array, pos, len) 				\

    70   (memset (g_array_elt_pos ((array), pos), 0,  g_array_elt_len ((array), len)))

    71 #define g_array_zero_terminate(array) G_STMT_START{			\

    72   if ((array)->zero_terminated)						\

    73     g_array_elt_zero ((array), (array)->len, 1);			\

    74 }G_STMT_END

    75 

    76 static gint g_nearest_pow        (gint        num) G_GNUC_CONST;

    77 static void g_array_maybe_expand (GRealArray *array,

    78 				  gint        len);

    79 #ifdef __SYMBIAN32__

    80 static void _g_array_maybe_expandP (GRealArray *array,

    81 				  gint        len);				  

    82 GArray* _g_array_sized_newP (gboolean zero_terminated,

    83 			   gboolean clear,

    84 			   guint    elt_size,

    85 			   guint    reserved_size);				  

    86 #endif // __SYMBIAN32__

    87 

    88 EXPORT_C GArray*

    89 g_array_new (gboolean zero_terminated,

    90 	     gboolean clear,

    91 	     guint    elt_size)

    92 {

    93   return (GArray*) g_array_sized_new (zero_terminated, clear, elt_size, 0);

    94 }

    95 

    96 #ifdef __SYMBIAN32__

    97 GArray*

    98 _g_array_newP (gboolean zero_terminated,

    99 	     gboolean clear,

   100 	     guint    elt_size)

   101 {

   102   return (GArray*) _g_array_sized_newP (zero_terminated, clear, elt_size, 0);

   103 }

   104 #endif // __SYMBIAN32__

   105 

   106 

   107 EXPORT_C GArray* g_array_sized_new (gboolean zero_terminated,

   108 			   gboolean clear,

   109 			   guint    elt_size,

   110 			   guint    reserved_size)

   111 {

   112   GRealArray *array = g_slice_new (GRealArray);

   113   array->data            = NULL;

   114   array->len             = 0;

   115   array->alloc           = 0;

   116   array->zero_terminated = (zero_terminated ? 1 : 0);

   117   array->clear           = (clear ? 1 : 0);

   118   array->elt_size        = elt_size;

   119 

   120   if (array->zero_terminated || reserved_size != 0)

   121     {

   122       g_array_maybe_expand (array, reserved_size);

   123       g_array_zero_terminate(array);

   124     }

   125 

   126   return (GArray*) array;

   127 }

   128 

   129 #ifdef __SYMBIAN32__

   130 GArray* _g_array_sized_newP (gboolean zero_terminated,

   131 			   gboolean clear,

   132 			   guint    elt_size,

   133 			   guint    reserved_size)

   134 {

   135   GRealArray *array = (GRealArray *)pAlloc(sizeof(GRealArray));

   136   array->data            = NULL;

   137   array->len             = 0;

   138   array->alloc           = 0;

   139   array->zero_terminated = (zero_terminated ? 1 : 0);

   140   array->clear           = (clear ? 1 : 0);

   141   array->elt_size        = elt_size;

   142 

   143   if (array->zero_terminated || reserved_size != 0)

   144     {

   145       _g_array_maybe_expandP (array, reserved_size);

   146       g_array_zero_terminate(array);

   147     }

   148 

   149   return (GArray*) array;

   150 }

   151 #endif // __SYMBIAN32__

   152 

   153 EXPORT_C gchar*

   154 g_array_free (GArray  *array,

   155 	      gboolean free_segment)

   156 {

   157   gchar* segment;

   158 

   159   g_return_val_if_fail (array, NULL);

   160 

   161   if (free_segment)

   162     {

   163       g_free (array->data);

   164       segment = NULL;

   165     }

   166   else

   167     segment = array->data;

   168 

   169   g_slice_free1 (sizeof (GRealArray), array);

   170 

   171   return segment;

   172 }

   173 

   174 #ifdef __SYMBIAN32__

   175 gchar*

   176 _g_array_freeP (GArray  *array,

   177 	      gboolean free_segment)

   178 {

   179   gchar* segment;

   180 

   181   g_return_val_if_fail (array, NULL);

   182 

   183   if (free_segment)

   184     {

   185       pFree(array->data);

   186       segment = NULL;

   187     }

   188   else

   189     segment = array->data;

   190 

   191   pFree(array);

   192 

   193   return segment;

   194 }

   195 #endif // __SYMBIAN32__

   196 

   197 EXPORT_C GArray*

   198 g_array_append_vals (GArray       *farray,

   199 		     gconstpointer data,

   200 		     guint         len)

   201 {

   202   GRealArray *array = (GRealArray*) farray;

   203 

   204   g_array_maybe_expand (array, len);

   205 

   206   memcpy (g_array_elt_pos (array, array->len), data, 

   207 	  g_array_elt_len (array, len));

   208 

   209   array->len += len;

   210 

   211   g_array_zero_terminate (array);

   212 

   213   return farray;

   214 }

   215 

   216 EXPORT_C GArray*

   217 g_array_prepend_vals (GArray        *farray,

   218 		      gconstpointer  data,

   219 		      guint          len)

   220 {

   221   GRealArray *array = (GRealArray*) farray;

   222 

   223   g_array_maybe_expand (array, len);

   224 

   225   g_memmove (g_array_elt_pos (array, len), g_array_elt_pos (array, 0), 

   226 	     g_array_elt_len (array, array->len));

   227 

   228   memcpy (g_array_elt_pos (array, 0), data, g_array_elt_len (array, len));

   229 

   230   array->len += len;

   231 

   232   g_array_zero_terminate (array);

   233 

   234   return farray;

   235 }

   236 

   237 EXPORT_C GArray*

   238 g_array_insert_vals (GArray        *farray,

   239 		     guint          index,

   240 		     gconstpointer  data,

   241 		     guint          len)

   242 {

   243   GRealArray *array = (GRealArray*) farray;

   244 

   245   g_array_maybe_expand (array, len);

   246 

   247   g_memmove (g_array_elt_pos (array, len + index), 

   248 	     g_array_elt_pos (array, index), 

   249 	     g_array_elt_len (array, array->len - index));

   250 

   251   memcpy (g_array_elt_pos (array, index), data, g_array_elt_len (array, len));

   252 

   253   array->len += len;

   254 

   255   g_array_zero_terminate (array);

   256 

   257   return farray;

   258 }

   259 

   260 EXPORT_C GArray*

   261 g_array_set_size (GArray *farray,

   262 		  guint   length)

   263 {

   264   GRealArray *array = (GRealArray*) farray;

   265   if (length > array->len)

   266     {

   267       g_array_maybe_expand (array, length - array->len);

   268       

   269       if (array->clear)

   270 	g_array_elt_zero (array, array->len, length - array->len);

   271     }

   272   else if (G_UNLIKELY (g_mem_gc_friendly) && length < array->len)

   273     g_array_elt_zero (array, length, array->len - length);

   274   

   275   array->len = length;

   276   

   277   g_array_zero_terminate (array);

   278   

   279   return farray;

   280 }

   281 

   282 #ifdef __SYMBIAN32__

   283 GArray*

   284 _g_array_set_sizeP (GArray *farray,

   285 		  guint   length)

   286 {

   287   GRealArray *array = (GRealArray*) farray;

   288   if (length > array->len)

   289     {

   290       _g_array_maybe_expandP (array, length - array->len);

   291       

   292       if (array->clear)

   293 	g_array_elt_zero (array, array->len, length - array->len);

   294     }

   295   else if (G_UNLIKELY (g_mem_gc_friendly) && length < array->len)

   296     g_array_elt_zero (array, length, array->len - length);

   297   

   298   array->len = length;

   299   

   300   g_array_zero_terminate (array);

   301   

   302   return farray;

   303 }

   304 #endif // __SYMBIAN32__

   305 

   306 EXPORT_C GArray*

   307 g_array_remove_index (GArray* farray,

   308 		      guint index)

   309 {

   310   GRealArray* array = (GRealArray*) farray;

   311 

   312   g_return_val_if_fail (array, NULL);

   313 

   314   g_return_val_if_fail (index < array->len, NULL);

   315 

   316   if (index != array->len - 1)

   317     g_memmove (g_array_elt_pos (array, index),

   318 	       g_array_elt_pos (array, index + 1),

   319 	       g_array_elt_len (array, array->len - index - 1));

   320   

   321   array->len -= 1;

   322 

   323   if (G_UNLIKELY (g_mem_gc_friendly))

   324     g_array_elt_zero (array, array->len, 1);

   325   else

   326     g_array_zero_terminate (array);

   327 

   328   return farray;

   329 }

   330 

   331 EXPORT_C GArray*

   332 g_array_remove_index_fast (GArray* farray,

   333 			   guint   index)

   334 {

   335   GRealArray* array = (GRealArray*) farray;

   336 

   337   g_return_val_if_fail (array, NULL);

   338 

   339   g_return_val_if_fail (index < array->len, NULL);

   340 

   341   if (index != array->len - 1)

   342     memcpy (g_array_elt_pos (array, index), 

   343 	    g_array_elt_pos (array, array->len - 1),

   344 	    g_array_elt_len (array, 1));

   345   

   346   array->len -= 1;

   347 

   348   if (G_UNLIKELY (g_mem_gc_friendly))

   349     g_array_elt_zero (array, array->len, 1);

   350   else

   351     g_array_zero_terminate (array);

   352 

   353   return farray;

   354 }

   355 

   356 EXPORT_C GArray*

   357 g_array_remove_range (GArray       *farray,

   358                       guint         index_,

   359                       guint         length)

   360 {

   361   GRealArray *array = (GRealArray*) farray;

   362 

   363   g_return_val_if_fail (array, NULL);

   364   g_return_val_if_fail (index_ < array->len, NULL);

   365   g_return_val_if_fail (index_ + length <= array->len, NULL);

   366 

   367   if (index_ + length != array->len)

   368     g_memmove (g_array_elt_pos (array, index_), 

   369                g_array_elt_pos (array, index_ + length), 

   370                (array->len - (index_ + length)) * array->elt_size);

   371 

   372   array->len -= length;

   373   if (G_UNLIKELY (g_mem_gc_friendly))

   374     g_array_elt_zero (array, array->len, length);

   375   else

   376     g_array_zero_terminate (array);

   377 

   378   return farray;

   379 }

   380 

   381 EXPORT_C void

   382 g_array_sort (GArray       *farray,

   383 	      GCompareFunc  compare_func)

   384 {

   385   GRealArray *array = (GRealArray*) farray;

   386 

   387   g_return_if_fail (array != NULL);

   388 

   389   qsort (array->data,

   390 	 array->len,

   391 	 array->elt_size,

   392 	 compare_func);

   393 }

   394 

   395 EXPORT_C void

   396 g_array_sort_with_data (GArray           *farray,

   397 			GCompareDataFunc  compare_func,

   398 			gpointer          user_data)

   399 {

   400   GRealArray *array = (GRealArray*) farray;

   401 

   402   g_return_if_fail (array != NULL);

   403 

   404   g_qsort_with_data (array->data,

   405 		     array->len,

   406 		     array->elt_size,

   407 		     compare_func,

   408 		     user_data);

   409 }

   410 

   411 

   412 static gint

   413 g_nearest_pow (gint num)

   414 {

   415   gint n = 1;

   416 

   417   while (n < num)

   418     n <<= 1;

   419 

   420   return n;

   421 }

   422 

   423 static void

   424 g_array_maybe_expand (GRealArray *array,

   425 		      gint        len)

   426 {

   427   guint want_alloc = g_array_elt_len (array, array->len + len + 

   428 				      array->zero_terminated);

   429 

   430   if (want_alloc > array->alloc)

   431     {

   432       want_alloc = g_nearest_pow (want_alloc);

   433       want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE);

   434       array->data = g_realloc (array->data, want_alloc);

   435 

   436       if (G_UNLIKELY (g_mem_gc_friendly))

   437         memset (array->data + array->alloc, 0, want_alloc - array->alloc);

   438 

   439       array->alloc = want_alloc;

   440     }

   441 }

   442 

   443 #ifdef __SYMBIAN32__

   444 

   445 static void

   446 _g_array_maybe_expandP (GRealArray *array,

   447 		      gint        len)

   448 {

   449   guint want_alloc = g_array_elt_len (array, array->len + len + 

   450 				      array->zero_terminated);

   451   guint8 * pData = NULL;

   452   if (want_alloc > array->alloc)

   453     {

   454       want_alloc = g_nearest_pow (want_alloc);

   455       want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE);

   456       array->data = (guint8 *)pReAlloc(array->data,want_alloc);

   457 

   458       if (G_UNLIKELY (g_mem_gc_friendly))

   459         memset (array->data + array->alloc, 0, want_alloc - array->alloc);

   460 

   461       array->alloc = want_alloc;

   462     }

   463 }

   464 #endif // __SYMBIAN32__

   465 

   466 /* Pointer Array

   467  */

   468 

   469 typedef struct _GRealPtrArray  GRealPtrArray;

   470 

   471 struct _GRealPtrArray

   472 {

   473   gpointer *pdata;

   474   guint     len;

   475   guint     alloc;

   476 };

   477 

   478 static void g_ptr_array_maybe_expand (GRealPtrArray *array,

   479 				      gint           len);

   480 

   481 EXPORT_C GPtrArray*

   482 g_ptr_array_new (void)

   483 {

   484   return g_ptr_array_sized_new (0);

   485 }

   486 

   487 EXPORT_C GPtrArray*  

   488 g_ptr_array_sized_new (guint reserved_size)

   489 {

   490   GRealPtrArray *array = g_slice_new (GRealPtrArray);

   491   array->pdata = NULL;

   492   array->len = 0;

   493   array->alloc = 0;

   494 

   495   if (reserved_size != 0)

   496     g_ptr_array_maybe_expand (array, reserved_size);

   497 

   498   return (GPtrArray*) array;  

   499 }

   500 

   501 EXPORT_C gpointer*

   502 g_ptr_array_free (GPtrArray   *array,

   503 		  gboolean  free_segment)

   504 {

   505   gpointer* segment;

   506 

   507   g_return_val_if_fail (array, NULL);

   508 

   509   if (free_segment)

   510     {

   511       g_free (array->pdata);

   512       segment = NULL;

   513     }

   514   else

   515     segment = array->pdata;

   516 

   517   g_slice_free1 (sizeof (GRealPtrArray), array);

   518 

   519   return segment;

   520 }

   521 

   522 static void

   523 g_ptr_array_maybe_expand (GRealPtrArray *array,

   524 			  gint        len)

   525 {

   526   if ((array->len + len) > array->alloc)

   527     {

   528       guint old_alloc = array->alloc;

   529       array->alloc = g_nearest_pow (array->len + len);

   530       array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);

   531       array->pdata = g_realloc (array->pdata, sizeof (gpointer) * array->alloc);

   532       if (G_UNLIKELY (g_mem_gc_friendly))

   533         for ( ; old_alloc < array->alloc; old_alloc++)

   534           array->pdata [old_alloc] = NULL;

   535     }

   536 }

   537 

   538 EXPORT_C void

   539 g_ptr_array_set_size  (GPtrArray   *farray,

   540 		       gint	     length)

   541 {

   542   GRealPtrArray* array = (GRealPtrArray*) farray;

   543 

   544   g_return_if_fail (array);

   545 

   546   if (length > array->len)

   547     {

   548       int i;

   549       g_ptr_array_maybe_expand (array, (length - array->len));

   550       /* This is not 

   551        *     memset (array->pdata + array->len, 0,

   552        *            sizeof (gpointer) * (length - array->len));

   553        * to make it really portable. Remember (void*)NULL needn't be

   554        * bitwise zero. It of course is silly not to use memset (..,0,..).

   555        */

   556       for (i = array->len; i < length; i++)

   557 	array->pdata[i] = NULL;

   558     }

   559   if (G_UNLIKELY (g_mem_gc_friendly) && length < array->len)

   560     {

   561       int i;

   562       for (i = length; i < array->len; i++)

   563 	array->pdata[i] = NULL;

   564     }

   565 

   566   array->len = length;

   567 }

   568 

   569 EXPORT_C gpointer

   570 g_ptr_array_remove_index (GPtrArray* farray,

   571 			  guint      index)

   572 {

   573   GRealPtrArray* array = (GRealPtrArray*) farray;

   574   gpointer result;

   575 

   576   g_return_val_if_fail (array, NULL);

   577 

   578   g_return_val_if_fail (index < array->len, NULL);

   579 

   580   result = array->pdata[index];

   581   

   582   if (index != array->len - 1)

   583     g_memmove (array->pdata + index, array->pdata + index + 1, 

   584 	       sizeof (gpointer) * (array->len - index - 1));

   585   

   586   array->len -= 1;

   587 

   588   if (G_UNLIKELY (g_mem_gc_friendly))

   589     array->pdata[array->len] = NULL;

   590 

   591   return result;

   592 }

   593 

   594 EXPORT_C gpointer

   595 g_ptr_array_remove_index_fast (GPtrArray* farray,

   596 			       guint      index)

   597 {

   598   GRealPtrArray* array = (GRealPtrArray*) farray;

   599   gpointer result;

   600 

   601   g_return_val_if_fail (array, NULL);

   602 

   603   g_return_val_if_fail (index < array->len, NULL);

   604 

   605   result = array->pdata[index];

   606   

   607   if (index != array->len - 1)

   608     array->pdata[index] = array->pdata[array->len - 1];

   609 

   610   array->len -= 1;

   611 

   612   if (G_UNLIKELY (g_mem_gc_friendly))

   613     array->pdata[array->len] = NULL;

   614 

   615   return result;

   616 }

   617 

   618 EXPORT_C void

   619 g_ptr_array_remove_range (GPtrArray* farray,

   620                           guint      index_,

   621                           guint      length)

   622 {

   623   GRealPtrArray* array = (GRealPtrArray*) farray;

   624 

   625   g_return_if_fail (array);

   626   g_return_if_fail (index_ < array->len);

   627   g_return_if_fail (index_ + length <= array->len);

   628 

   629   if (index_ + length != array->len)

   630     g_memmove (&array->pdata[index_],

   631                &array->pdata[index_ + length], 

   632                (array->len - (index_ + length)) * sizeof (gpointer));

   633 

   634   array->len -= length;

   635   if (G_UNLIKELY (g_mem_gc_friendly))

   636     {

   637       guint i;

   638       for (i = 0; i < length; i++)

   639         array->pdata[array->len + i] = NULL;

   640     }

   641 }

   642 

   643 EXPORT_C gboolean

   644 g_ptr_array_remove (GPtrArray* farray,

   645 		    gpointer data)

   646 {

   647   GRealPtrArray* array = (GRealPtrArray*) farray;

   648   guint i;

   649 

   650   g_return_val_if_fail (array, FALSE);

   651 

   652   for (i = 0; i < array->len; i += 1)

   653     {

   654       if (array->pdata[i] == data)

   655 	{

   656 	  g_ptr_array_remove_index (farray, i);

   657 	  return TRUE;

   658 	}

   659     }

   660 

   661   return FALSE;

   662 }

   663 

   664 EXPORT_C gboolean

   665 g_ptr_array_remove_fast (GPtrArray* farray,

   666 			 gpointer data)

   667 {

   668   GRealPtrArray* array = (GRealPtrArray*) farray;

   669   guint i;

   670 

   671   g_return_val_if_fail (array, FALSE);

   672 

   673   for (i = 0; i < array->len; i += 1)

   674     {

   675       if (array->pdata[i] == data)

   676 	{

   677 	  g_ptr_array_remove_index_fast (farray, i);

   678 	  return TRUE;

   679 	}

   680     }

   681 

   682   return FALSE;

   683 }

   684 

   685 EXPORT_C void

   686 g_ptr_array_add (GPtrArray* farray,

   687 		 gpointer data)

   688 {

   689   GRealPtrArray* array = (GRealPtrArray*) farray;

   690 

   691   g_return_if_fail (array);

   692 

   693   g_ptr_array_maybe_expand (array, 1);

   694 

   695   array->pdata[array->len++] = data;

   696 }

   697 

   698 EXPORT_C void

   699 g_ptr_array_sort (GPtrArray    *array,

   700 		  GCompareFunc  compare_func)

   701 {

   702   g_return_if_fail (array != NULL);

   703 

   704   qsort (array->pdata,

   705 	 array->len,

   706 	 sizeof (gpointer),

   707 	 compare_func);

   708 }

   709 

   710 EXPORT_C void

   711 g_ptr_array_sort_with_data (GPtrArray        *array,

   712 			    GCompareDataFunc  compare_func,

   713 			    gpointer          user_data)

   714 {

   715   g_return_if_fail (array != NULL);

   716 

   717   g_qsort_with_data (array->pdata,

   718 		     array->len,

   719 		     sizeof (gpointer),

   720 		     compare_func,

   721 		     user_data);

   722 }

   723 

   724 /**

   725  * g_ptr_array_foreach:

   726  * @array: a #GPtrArray

   727  * @func: the function to call for each array element

   728  * @user_data: user data to pass to the function

   729  * 

   730  * Calls a function for each element of a #GPtrArray.

   731  *

   732  * Since: 2.4

   733  **/

   734 EXPORT_C void

   735 g_ptr_array_foreach (GPtrArray *array,

   736                      GFunc      func,

   737                      gpointer   user_data)

   738 {

   739   guint i;

   740 

   741   g_return_if_fail (array);

   742 

   743   for (i = 0; i < array->len; i++)

   744     (*func) (array->pdata[i], user_data);

   745 }

   746 

   747 /* Byte arrays 

   748  */

   749 

   750 EXPORT_C GByteArray* g_byte_array_new      (void)

   751 {

   752   return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, 0);

   753 }

   754 

   755 EXPORT_C GByteArray* g_byte_array_sized_new (guint reserved_size)

   756 {

   757   return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, reserved_size);

   758 }

   759 

   760 EXPORT_C guint8*	    g_byte_array_free     (GByteArray *array,

   761 			           gboolean    free_segment)

   762 {

   763   return (guint8*) g_array_free ((GArray*) array, free_segment);

   764 }

   765 

   766 EXPORT_C GByteArray* g_byte_array_append   (GByteArray *array,

   767 				   const guint8 *data,

   768 				   guint       len)

   769 {

   770   g_array_append_vals ((GArray*) array, (guint8*)data, len);

   771 

   772   return array;

   773 }

   774 

   775 EXPORT_C GByteArray* g_byte_array_prepend  (GByteArray *array,

   776 				   const guint8 *data,

   777 				   guint       len)

   778 {

   779   g_array_prepend_vals ((GArray*) array, (guint8*)data, len);

   780 

   781   return array;

   782 }

   783 

   784 EXPORT_C GByteArray* g_byte_array_set_size (GByteArray *array,

   785 				   guint       length)

   786 {

   787   g_array_set_size ((GArray*) array, length);

   788 

   789   return array;

   790 }

   791 

   792 EXPORT_C GByteArray* g_byte_array_remove_index (GByteArray *array,

   793 				       guint index)

   794 {

   795   g_array_remove_index((GArray*) array, index);

   796 

   797   return array;

   798 }

   799 

   800 EXPORT_C GByteArray* g_byte_array_remove_index_fast (GByteArray *array,

   801 					    guint index)

   802 {

   803   g_array_remove_index_fast((GArray*) array, index);

   804 

   805   return array;

   806 }

   807 

   808 EXPORT_C GByteArray*

   809 g_byte_array_remove_range (GByteArray *array,

   810                            guint index_,

   811                            guint length)

   812 {

   813   g_return_val_if_fail (array, NULL);

   814   g_return_val_if_fail (index_ < array->len, NULL);

   815   g_return_val_if_fail (index_ + length <= array->len, NULL);

   816 

   817   return (GByteArray *)g_array_remove_range ((GArray*) array, index_, length);

   818 }

   819 

   820 EXPORT_C void

   821 g_byte_array_sort (GByteArray   *array,

   822 		   GCompareFunc  compare_func)

   823 {

   824   g_array_sort ((GArray *) array, compare_func);

   825 }

   826 

   827 EXPORT_C void

   828 g_byte_array_sort_with_data (GByteArray       *array,

   829 			     GCompareDataFunc  compare_func,

   830 			     gpointer          user_data)

   831 {

   832   g_array_sort_with_data ((GArray *) array, compare_func, user_data);

   833 }

   834 

   835 #define __G_ARRAY_C__

   836 #include "galiasdef.c"