| GLib Reference Manual |
|---|
Byte ArraysByte Arrays — arrays of bytes, which grow automatically as elements are added. |
#include <glib.h>
GByteArray;
GByteArray* g_byte_array_new (void);
GByteArray* g_byte_array_sized_new (guint reserved_size);
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_remove_index (GByteArray *array,
guint index_);
GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
guint index_);
GByteArray* g_byte_array_remove_range (GByteArray *array,
guint index_,
guint length);
void g_byte_array_sort (GByteArray *array,
GCompareFunc compare_func);
void g_byte_array_sort_with_data (GByteArray *array,
GCompareDataFunc compare_func,
gpointer user_data);
GByteArray* g_byte_array_set_size (GByteArray *array,
guint length);
guint8* g_byte_array_free (GByteArray *array,
gboolean free_segment);
GByteArray is based on GArray, to provide arrays of bytes which grow automatically as elements are added.
To create a new GByteArray use g_byte_array_new().
To add elements to a GByteArray, use g_byte_array_append(), and g_byte_array_prepend().
To set the size of a GByteArray, use g_byte_array_set_size().
To free a GByteArray, use g_byte_array_free().
Example 6. Using a GByteArray
GByteArray *gbarray;
gint i;
gbarray = g_byte_array_new ();
for (i = 0; i < 10000; i++)
g_byte_array_append (gbarray, (guint8*) "abcd", 4);
for (i = 0; i < 10000; i++)
{
g_assert (gbarray->data[4*i] == 'a');
g_assert (gbarray->data[4*i+1] == 'b');
g_assert (gbarray->data[4*i+2] == 'c');
g_assert (gbarray->data[4*i+3] == 'd');
}
g_byte_array_free (gbarray, TRUE);
typedef struct {
guint8 *data;
guint len;
} GByteArray;
The GByteArray struct allows access to the public fields of a GByteArray.
| guint8 *data; | a pointer to the element data. The data may be moved as elements are added to the GByteArray. |
| guint len; | the number of elements in the GByteArray. |
GByteArray* g_byte_array_new (void);
Creates a new GByteArray.
| Returns : | the new GByteArray. |
GByteArray* g_byte_array_sized_new (guint reserved_size);
Creates a new GByteArray with reserved_size bytes preallocated. This avoids frequent reallocation, if you are going to add many bytes to the array. Note however that the size of the array is still 0.
| reserved_size : | number of bytes preallocated. |
| Returns : | the new GByteArray. |
GByteArray* g_byte_array_append (GByteArray *array, const guint8 *data, guint len);
Adds the given bytes to the end of the GByteArray. The array will grow in size automatically if necessary.
| array : | a GByteArray. |
| data : | the byte data to be added. |
| len : | the number of bytes to add. |
| Returns : | the GByteArray. |
GByteArray* g_byte_array_prepend (GByteArray *array, const guint8 *data, guint len);
Adds the given data to the start of the GByteArray. The array will grow in size automatically if necessary.
| array : | a GByteArray. |
| data : | the byte data to be added. |
| len : | the number of bytes to add. |
| Returns : | the GByteArray. |
GByteArray* g_byte_array_remove_index (GByteArray *array, guint index_);
Removes the byte at the given index from a GByteArray. The following bytes are moved down one place.
| array : | a GByteArray. |
| index_ : | the index of the byte to remove. |
| Returns : | the GByteArray. |
GByteArray* g_byte_array_remove_index_fast (GByteArray *array, guint index_);
Removes the byte at the given index from a GByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the GByteArray. But it is faster than g_byte_array_remove_index().
| array : | a GByteArray. |
| index_ : | the index of the byte to remove. |
| Returns : | the GByteArray. |
GByteArray* g_byte_array_remove_range (GByteArray *array, guint index_, guint length);
Removes the given number of bytes starting at the given index from a GByteArray. The following elements are moved to close the gap.
| array : | a GByteArray. |
| index_ : | the index of the first byte to remove. |
| length : | the number of bytes to remove. |
| Returns : | the GByteArray. |
Since 2.4
void g_byte_array_sort (GByteArray *array, GCompareFunc compare_func);
Sorts a byte array, using compare_func which should be a qsort()-style comparison function (returns -1 for first arg is less than second arg, 0 for equal, 1 if first arg is greater than second arg).
| array : | a GByteArray. |
| compare_func : | comparison function. |
void g_byte_array_sort_with_data (GByteArray *array, GCompareDataFunc compare_func, gpointer user_data);
Like g_byte_array_sort(), but the comparison function takes a user data argument.
| array : | a GByteArray. |
| compare_func : | comparison function. |
| user_data : | data to pass to compare_func. |
GByteArray* g_byte_array_set_size (GByteArray *array, guint length);
Sets the size of the GByteArray, expanding it if necessary.
| array : | a GByteArray. |
| length : | the new size of the GByteArray. |
| Returns : | the GByteArray. |
guint8* g_byte_array_free (GByteArray *array, gboolean free_segment);
Frees the memory allocated by the GByteArray. If free_segment is TRUE it frees the actual byte data.
| array : | a GByteArray. |
| free_segment : | if TRUE the actual byte data is freed as well. |
| Returns : |
| << Pointer Arrays | Balanced Binary Trees >> |