struct GBitArray

struct GBitArray;

g_bit_array_new ()

GBitArray *         g_bit_array_new                     (guint bit_length);

Returns a new GBitArray with the given length. Note that the bit states are undefined.

g_bit_array_resize ()

GBitArray *         g_bit_array_resize                  (GBitArray *array,
                                                         guint bit_length);

Resizes the GBitArray to the specified length. All bits are cleared after this operation.

g_bit_array_extend ()

GBitArray *         g_bit_array_extend                  (GBitArray *array,
                                                         guint num);

Extends array by num bits. Unlike g_bit_array_resize(), maintains the existing bits. New bits are cleared.

g_bit_array_copy ()

void                g_bit_array_copy                    (GBitArray *lhs,
                                                         const GBitArray *rhs);

Resizes lhs as necessary.

g_bit_array_get_len ()

guint               g_bit_array_get_len                 (const GBitArray *array);

Returns the bit length of the array.

g_bit_array_get_num_set ()

guint               g_bit_array_get_num_set             (const GBitArray *array);

g_bit_array_get_bit ()

gboolean            g_bit_array_get_bit                 (const GBitArray *array,
                                                         guint pos);

Returns whether or not the bit indexed by pos is set. The index must satisfy 0 <= pos < length.

g_bit_array_set_bit ()

GBitArray *         g_bit_array_set_bit                 (GBitArray *array,
                                                         guint pos);

Sets the bit indexed by pos to TRUE. The index must satisfy 0 <= pos < length.

g_bit_array_clear_bit ()

GBitArray *         g_bit_array_clear_bit               (GBitArray *array,
                                                         guint pos);

Sets the bit indexed by pos to FALSE. The index must satisfy 0 <= pos < length.

g_bit_array_flip_bit ()

gboolean            g_bit_array_flip_bit                (GBitArray *array,
                                                         guint pos);

Negates the bit indexed by pos. The index must satisfy 0 <= pos < length.

g_bit_array_set_bit_val ()

GBitArray *         g_bit_array_set_bit_val             (GBitArray *array,
                                                         guint pos,
                                                         gboolean val);

Sets the bit indexed by pos to val. The index must satisfy 0 <= pos < length.

g_bit_array_set_range ()

GBitArray *         g_bit_array_set_range               (GBitArray *array,
                                                         guint start,
                                                         guint stop,
                                                         gboolean val);

Sets all of the bits between start and stop (inclusive) to val. The indeces must satisfy 0 <= start <= stop < length.

g_bit_array_reset ()

GBitArray *         g_bit_array_reset                   (GBitArray *array,
                                                         gboolean val);

Sets all of the bits in the array to val.

g_bit_array_equal ()

gboolean            g_bit_array_equal                   (GBitArray *lhs,
                                                         GBitArray *rhs);

If lhs and rhs are not the same length, returns FALSE.

g_bit_array_serial_compare ()

gint                g_bit_array_serial_compare          (const GBitArray *a,
                                                         const GBitArray *b);

Compares a serialization of a and b. The serialization interprets the bit array as a base-2 integer.

g_bit_array_iter_reset ()

void                g_bit_array_iter_reset              (GBitArray *array);

Restarts the iterator at the beginning. The next call to g_bit_array_iter_next() will return the index of the first true bit.

g_bit_array_iter_next ()

gint                g_bit_array_iter_next               (GBitArray *array);

Returns the index of the next TRUE bit. Returns -1 when the end of the array has been reached.