Main Page | Class List | Directories | File List | Class Members | File Members

garray.c File Reference

#include <string.h>
#include "glib.h"

Go to the source code of this file.

Classes

struct  _GRealArray
struct  _GRealPtrArray

Defines

#define MIN_ARRAY_SIZE   16

Typedefs

typedef _GRealArray GRealArray
typedef _GRealPtrArray GRealPtrArray

Functions

static gint g_nearest_pow (gint num)
static void g_array_maybe_expand (GRealArray *array, gint len)
 G_LOCK_DEFINE_STATIC (array_mem_chunk)
GArray * g_array_new (gboolean zero_terminated, gboolean clear, guint elt_size)
void g_array_free (GArray *array, gboolean free_segment)
GArray * g_array_append_vals (GArray *farray, gconstpointer data, guint len)
GArray * g_array_prepend_vals (GArray *farray, gconstpointer data, guint len)
GArray * g_array_insert_vals (GArray *farray, guint index, gconstpointer data, guint len)
GArray * g_array_set_size (GArray *farray, guint length)
GArray * g_array_remove_index (GArray *farray, guint index)
GArray * g_array_remove_index_fast (GArray *farray, guint index)
static void g_ptr_array_maybe_expand (GRealPtrArray *array, gint len)
GPtrArray * g_ptr_array_new (void)
void g_ptr_array_free (GPtrArray *array, gboolean free_segment)
void g_ptr_array_set_size (GPtrArray *farray, gint length)
gpointer g_ptr_array_remove_index (GPtrArray *farray, guint index)
gpointer g_ptr_array_remove_index_fast (GPtrArray *farray, guint index)
gboolean g_ptr_array_remove (GPtrArray *farray, gpointer data)
gboolean g_ptr_array_remove_fast (GPtrArray *farray, gpointer data)
void g_ptr_array_add (GPtrArray *farray, gpointer data)
GByteArray * g_byte_array_new (void)
void g_byte_array_free (GByteArray *array, gboolean free_segment)
GByteArray * g_byte_array_append (GByteArray *array, const guint8 *data, guint len)
GByteArray * g_byte_array_prepend (GByteArray *array, const guint8 *data, guint len)
GByteArray * g_byte_array_set_size (GByteArray *array, guint length)
GByteArray * g_byte_array_remove_index (GByteArray *array, guint index)
GByteArray * g_byte_array_remove_index_fast (GByteArray *array, guint index)

Variables

static GMemChunk * array_mem_chunk = NULL
static GMemChunk * ptr_array_mem_chunk = NULL

Define Documentation

#define MIN_ARRAY_SIZE   16
 

Definition at line 35 of file garray.c.

Referenced by g_array_maybe_expand(), and g_ptr_array_maybe_expand().

Typedef Documentation

typedef struct _GRealArray GRealArray
 

Definition at line 38 of file garray.c.

typedef struct _GRealPtrArray GRealPtrArray
 

Definition at line 247 of file garray.c.

Function Documentation

GArray* g_array_append_vals (  GArray *  farray,
gconstpointer  data,
guint  len
) 
 

Definition at line 97 of file garray.c.

References array, _GRealArray::data, _GRealArray::elt_size, g_array_maybe_expand(), and _GRealArray::len.

Referenced by g_byte_array_append().

00100 {
00101   GRealArray *array = (GRealArray*) farray;
00102 
00103   g_array_maybe_expand (array, len);
00104 
00105   memcpy (array->data + array->elt_size * array->len, data, array->elt_size * len);
00106 
00107   array->len += len;
00108 
00109   return farray;
00110 }

void g_array_free (  GArray *  array,
gboolean  free_segment
) 
 

Definition at line 85 of file garray.c.

References array_mem_chunk, _GArray::data, g_free(), G_LOCK, g_mem_chunk_free(), and G_UNLOCK.

Referenced by g_byte_array_free(), and main().

00087 {
00088   if (free_segment)
00089     g_free (array->data);
00090 
00091   G_LOCK (array_mem_chunk);
00092   g_mem_chunk_free (array_mem_chunk, array);
00093   G_UNLOCK (array_mem_chunk);
00094 }

GArray* g_array_insert_vals (  GArray *  farray,
guint  index,
gconstpointer  data,
guint  len
) 
 

Definition at line 131 of file garray.c.

References array, _GRealArray::data, _GRealArray::elt_size, g_array_maybe_expand(), and _GRealArray::len.

00135 {
00136   GRealArray *array = (GRealArray*) farray;
00137 
00138   g_array_maybe_expand (array, len);
00139 
00140   g_memmove (array->data + array->elt_size * (len + index), 
00141              array->data + array->elt_size * index, 
00142              array->elt_size * (array->len - index));
00143 
00144   memcpy (array->data + array->elt_size * index, data, len * array->elt_size);
00145 
00146   array->len += len;
00147 
00148   return farray;
00149 }

static void g_array_maybe_expand (  GRealArray *  array,
gint  len
)  [static]
 

Definition at line 225 of file garray.c.

References _GRealArray::alloc, _GRealArray::clear, _GRealArray::data, _GRealArray::elt_size, g_nearest_pow(), g_realloc(), _GRealArray::len, MAX, MIN_ARRAY_SIZE, and _GRealArray::zero_terminated.

Referenced by g_array_append_vals(), g_array_insert_vals(), g_array_prepend_vals(), and g_array_set_size().

00227 {
00228   guint want_alloc = (array->len + len + array->zero_terminated) * array->elt_size;
00229 
00230   if (want_alloc > array->alloc)
00231     {
00232       guint old_alloc = array->alloc;
00233 
00234       array->alloc = g_nearest_pow (want_alloc);
00235       array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
00236 
00237       array->data = g_realloc (array->data, array->alloc);
00238 
00239       if (array->clear || array->zero_terminated)
00240         memset (array->data + old_alloc, 0, array->alloc - old_alloc);
00241     }
00242 }

GArray* g_array_new (  gboolean  zero_terminated,
gboolean  clear,
guint  elt_size
) 
 

Definition at line 59 of file garray.c.

References _GRealArray::alloc, array, array_mem_chunk, _GRealArray::clear, _GRealArray::data, _GRealArray::elt_size, G_ALLOC_AND_FREE, g_chunk_new, G_LOCK, g_mem_chunk_new(), G_UNLOCK, _GRealArray::len, NULL, and _GRealArray::zero_terminated.

Referenced by g_byte_array_new(), g_static_private_set(), and main().

00062 {
00063   GRealArray *array;
00064 
00065   G_LOCK (array_mem_chunk);
00066   if (!array_mem_chunk)
00067     array_mem_chunk = g_mem_chunk_new ("array mem chunk",
00068                                        sizeof (GRealArray),
00069                                        1024, G_ALLOC_AND_FREE);
00070 
00071   array = g_chunk_new (GRealArray, array_mem_chunk);
00072   G_UNLOCK (array_mem_chunk);
00073 
00074   array->data            = NULL;
00075   array->len             = 0;
00076   array->alloc           = 0;
00077   array->zero_terminated = (zero_terminated ? 1 : 0);
00078   array->clear           = (clear ? 1 : 0);
00079   array->elt_size        = elt_size;
00080 
00081   return (GArray*) array;
00082 }

GArray* g_array_prepend_vals (  GArray *  farray,
gconstpointer  data,
guint  len
) 
 

Definition at line 113 of file garray.c.

References array, _GRealArray::data, _GRealArray::elt_size, g_array_maybe_expand(), and _GRealArray::len.

Referenced by g_byte_array_prepend().

00116 {
00117   GRealArray *array = (GRealArray*) farray;
00118 
00119   g_array_maybe_expand (array, len);
00120 
00121   g_memmove (array->data + array->elt_size * len, array->data, array->elt_size * array->len);
00122 
00123   memcpy (array->data, data, len * array->elt_size);
00124 
00125   array->len += len;
00126 
00127   return farray;
00128 }

GArray* g_array_remove_index (  GArray *  farray,
guint  index
) 
 

Definition at line 166 of file garray.c.

References array, _GRealArray::data, _GRealArray::elt_size, g_return_val_if_fail, _GRealArray::len, NULL, and _GRealArray::zero_terminated.

Referenced by g_byte_array_remove_index().

00168 {
00169   GRealArray* array = (GRealArray*) farray;
00170 
00171   g_return_val_if_fail (array, NULL);
00172 
00173   g_return_val_if_fail (index < array->len, NULL);
00174 
00175   if (index != array->len - 1)
00176       g_memmove (array->data + array->elt_size * index, 
00177                  array->data + array->elt_size * (index + 1), 
00178                  array->elt_size * (array->len - index - 1));
00179   
00180   if (array->zero_terminated)
00181     memset (array->data + array->elt_size * (array->len - 1), 0, 
00182             array->elt_size);
00183 
00184   array->len -= 1;
00185 
00186   return farray;
00187 }

GArray* g_array_remove_index_fast (  GArray *  farray,
guint  index
) 
 

Definition at line 190 of file garray.c.

References array, _GRealArray::data, _GRealArray::elt_size, g_return_val_if_fail, _GRealArray::len, NULL, and _GRealArray::zero_terminated.

Referenced by g_byte_array_remove_index_fast().

00192 {
00193   GRealArray* array = (GRealArray*) farray;
00194 
00195   g_return_val_if_fail (array, NULL);
00196 
00197   g_return_val_if_fail (index < array->len, NULL);
00198 
00199   if (index != array->len - 1)
00200     g_memmove (array->data + array->elt_size * index, 
00201                array->data + array->elt_size * (array->len - 1), 
00202                array->elt_size);
00203   
00204   if (array->zero_terminated)
00205     memset (array->data + array->elt_size * (array->len - 1), 0, 
00206             array->elt_size);
00207 
00208   array->len -= 1;
00209 
00210   return farray;
00211 }

GArray* g_array_set_size (  GArray *  farray,
guint  length
) 
 

Definition at line 152 of file garray.c.

References array, g_array_maybe_expand(), and _GRealArray::len.

Referenced by g_byte_array_set_size(), and g_static_private_set().

00154 {
00155   GRealArray *array = (GRealArray*) farray;
00156 
00157   if (array->len < length)
00158     g_array_maybe_expand (array, length - array->len);
00159 
00160   array->len = length;
00161 
00162   return farray;
00163 }

GByteArray* g_byte_array_append (  GByteArray *  array,
const guint8 *  data,
guint  len
) 
 

Definition at line 450 of file garray.c.

References g_array_append_vals().

Referenced by main().

00453 {
00454   g_array_append_vals ((GArray*) array, (guint8*)data, len);
00455 
00456   return array;
00457 }

void g_byte_array_free (  GByteArray *  array,
gboolean  free_segment
) 
 

Definition at line 444 of file garray.c.

References g_array_free().

Referenced by main().

00446 {
00447   g_array_free ((GArray*) array, free_segment);
00448 }

GByteArray* g_byte_array_new (  void   ) 
 

Definition at line 439 of file garray.c.

References FALSE, and g_array_new().

Referenced by main().

00440 {
00441   return (GByteArray*) g_array_new (FALSE, FALSE, 1);
00442 }

GByteArray* g_byte_array_prepend (  GByteArray *  array,
const guint8 *  data,
guint  len
) 
 

Definition at line 459 of file garray.c.

References g_array_prepend_vals().

00462 {
00463   g_array_prepend_vals ((GArray*) array, (guint8*)data, len);
00464 
00465   return array;
00466 }

GByteArray* g_byte_array_remove_index (  GByteArray *  array,
guint  index
) 
 

Definition at line 476 of file garray.c.

References g_array_remove_index().

00478 {
00479   g_array_remove_index((GArray*) array, index);
00480 
00481   return array;
00482 }

GByteArray* g_byte_array_remove_index_fast (  GByteArray *  array,
guint  index
) 
 

Definition at line 484 of file garray.c.

References g_array_remove_index_fast().

00486 {
00487   g_array_remove_index_fast((GArray*) array, index);
00488 
00489   return array;
00490 }

GByteArray* g_byte_array_set_size (  GByteArray *  array,
guint  length
) 
 

Definition at line 468 of file garray.c.

References g_array_set_size().

00470 {
00471   g_array_set_size ((GArray*) array, length);
00472 
00473   return array;
00474 }

G_LOCK_DEFINE_STATIC (  array_mem_chunk   ) 
 

static gint g_nearest_pow (  gint  num  )  [static]
 

Definition at line 214 of file garray.c.

Referenced by g_array_maybe_expand(), and g_ptr_array_maybe_expand().

00215 {
00216   gint n = 1;
00217 
00218   while (n < num)
00219     n <<= 1;
00220 
00221   return n;
00222 }

void g_ptr_array_add (  GPtrArray *  farray,
gpointer  data
) 
 

Definition at line 424 of file garray.c.

References array, g_ptr_array_maybe_expand(), g_return_if_fail, _GRealPtrArray::len, and _GRealPtrArray::pdata.

Referenced by main().

00426 {
00427   GRealPtrArray* array = (GRealPtrArray*) farray;
00428 
00429   g_return_if_fail (array);
00430 
00431   g_ptr_array_maybe_expand (array, 1);
00432 
00433   array->pdata[array->len++] = data;
00434 }

void g_ptr_array_free (  GPtrArray *  array,
gboolean  free_segment
) 
 

Definition at line 285 of file garray.c.

References g_free(), G_LOCK, g_mem_chunk_free(), g_return_if_fail, G_UNLOCK, _GPtrArray::pdata, and ptr_array_mem_chunk.

Referenced by main().

00287 {
00288   g_return_if_fail (array);
00289 
00290   if (free_segment)
00291     g_free (array->pdata);
00292 
00293   G_LOCK (ptr_array_mem_chunk);
00294   g_mem_chunk_free (ptr_array_mem_chunk, array);
00295   G_UNLOCK (ptr_array_mem_chunk);
00296 }

static void g_ptr_array_maybe_expand (  GRealPtrArray *  array,
gint  len
)  [static]
 

Definition at line 299 of file garray.c.

References _GRealPtrArray::alloc, g_nearest_pow(), g_new0, g_realloc(), _GRealPtrArray::len, MAX, MIN_ARRAY_SIZE, and _GRealPtrArray::pdata.

Referenced by g_ptr_array_add(), and g_ptr_array_set_size().

00301 {
00302   guint old_alloc;
00303 
00304   if ((array->len + len) > array->alloc)
00305     {
00306       old_alloc = array->alloc;
00307 
00308       array->alloc = g_nearest_pow (array->len + len);
00309       array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
00310       if (array->pdata)
00311         array->pdata = g_realloc (array->pdata, sizeof(gpointer) * array->alloc);
00312       else
00313         array->pdata = g_new0 (gpointer, array->alloc);
00314 
00315       memset (array->pdata + old_alloc, 0, 
00316               sizeof (gpointer) * (array->alloc - old_alloc));
00317     }
00318 }

GPtrArray* g_ptr_array_new (  void   ) 
 

Definition at line 264 of file garray.c.

References _GRealPtrArray::alloc, array, G_ALLOC_AND_FREE, g_chunk_new, G_LOCK, g_mem_chunk_new(), G_UNLOCK, _GRealPtrArray::len, NULL, _GRealPtrArray::pdata, and ptr_array_mem_chunk.

Referenced by main().

00265 {
00266   GRealPtrArray *array;
00267 
00268   G_LOCK (ptr_array_mem_chunk);
00269   if (!ptr_array_mem_chunk)
00270     ptr_array_mem_chunk = g_mem_chunk_new ("array mem chunk",
00271                                            sizeof (GRealPtrArray),
00272                                            1024, G_ALLOC_AND_FREE);
00273 
00274   array = g_chunk_new (GRealPtrArray, ptr_array_mem_chunk);
00275   G_UNLOCK (ptr_array_mem_chunk);
00276 
00277   array->pdata = NULL;
00278   array->len = 0;
00279   array->alloc = 0;
00280 
00281   return (GPtrArray*) array;
00282 }

gboolean g_ptr_array_remove (  GPtrArray *  farray,
gpointer  data
) 
 

Definition at line 382 of file garray.c.

References array, FALSE, g_ptr_array_remove_index(), g_return_val_if_fail, _GRealPtrArray::pdata, and TRUE.

00384 {
00385   GRealPtrArray* array = (GRealPtrArray*) farray;
00386   int i;
00387 
00388   g_return_val_if_fail (array, FALSE);
00389 
00390   for (i = 0; i < array->len; i += 1)
00391     {
00392       if (array->pdata[i] == data)
00393         {
00394           g_ptr_array_remove_index (farray, i);
00395           return TRUE;
00396         }
00397     }
00398 
00399   return FALSE;
00400 }

gboolean g_ptr_array_remove_fast (  GPtrArray *  farray,
gpointer  data
) 
 

Definition at line 403 of file garray.c.

References array, FALSE, g_ptr_array_remove_index_fast(), g_return_val_if_fail, _GRealPtrArray::pdata, and TRUE.

00405 {
00406   GRealPtrArray* array = (GRealPtrArray*) farray;
00407   int i;
00408 
00409   g_return_val_if_fail (array, FALSE);
00410 
00411   for (i = 0; i < array->len; i += 1)
00412     {
00413       if (array->pdata[i] == data)
00414         {
00415           g_ptr_array_remove_index_fast (farray, i);
00416           return TRUE;
00417         }
00418     }
00419 
00420   return FALSE;
00421 }

gpointer g_ptr_array_remove_index (  GPtrArray *  farray,
guint  index
) 
 

Definition at line 335 of file garray.c.

References array, g_return_val_if_fail, _GRealPtrArray::len, NULL, and _GRealPtrArray::pdata.

Referenced by g_ptr_array_remove().

00337 {
00338   GRealPtrArray* array = (GRealPtrArray*) farray;
00339   gpointer result;
00340 
00341   g_return_val_if_fail (array, NULL);
00342 
00343   g_return_val_if_fail (index < array->len, NULL);
00344 
00345   result = array->pdata[index];
00346   
00347   if (index != array->len - 1)
00348     g_memmove (array->pdata + index, array->pdata + index + 1, 
00349                sizeof (gpointer) * (array->len - index - 1));
00350   
00351   array->pdata[array->len - 1] = NULL;
00352 
00353   array->len -= 1;
00354 
00355   return result;
00356 }

gpointer g_ptr_array_remove_index_fast (  GPtrArray *  farray,
guint  index
) 
 

Definition at line 359 of file garray.c.

References array, g_return_val_if_fail, _GRealPtrArray::len, NULL, and _GRealPtrArray::pdata.

Referenced by g_ptr_array_remove_fast().

00361 {
00362   GRealPtrArray* array = (GRealPtrArray*) farray;
00363   gpointer result;
00364 
00365   g_return_val_if_fail (array, NULL);
00366 
00367   g_return_val_if_fail (index < array->len, NULL);
00368 
00369   result = array->pdata[index];
00370   
00371   if (index != array->len - 1)
00372     array->pdata[index] = array->pdata[array->len - 1];
00373 
00374   array->pdata[array->len - 1] = NULL;
00375 
00376   array->len -= 1;
00377 
00378   return result;
00379 }

void g_ptr_array_set_size (  GPtrArray *  farray,
gint  length
) 
 

Definition at line 321 of file garray.c.

References array, g_ptr_array_maybe_expand(), g_return_if_fail, and _GRealPtrArray::len.

00323 {
00324   GRealPtrArray* array = (GRealPtrArray*) farray;
00325 
00326   g_return_if_fail (array);
00327 
00328   if (length > array->len)
00329     g_ptr_array_maybe_expand (array, (length - array->len));
00330 
00331   array->len = length;
00332 }

Variable Documentation

GMemChunk* array_mem_chunk = NULL [static]
 

Definition at line 55 of file garray.c.

Referenced by g_array_free(), and g_array_new().

GMemChunk* ptr_array_mem_chunk = NULL [static]
 

Definition at line 259 of file garray.c.

Referenced by g_ptr_array_free(), and g_ptr_array_new().

© sourcejam.com 2005-2008