Memory-managed wrapper type.

Construct a ByteArray struct initialized to zero.

Adds the given bytes to the end of the ByteArray. The array will grow in size automatically if necessary.

Frees the memory allocated by the ByteArray. If freeSegment is True it frees the actual byte data. If the reference count of array is greater than one, the ByteArray wrapper is preserved but the size of array will be set to zero.

Transfers the data from the ByteArray into a new immutable Bytes.

The ByteArray is freed unless the reference count of array is greater than one, the ByteArray wrapper is preserved but the size of array will be set to zero.

This is identical to using bytesNewTake and byteArrayFree together.

Since: 2.32

Creates a new ByteArray with a reference count of 1.

Creates a byte array containing the data. After this call, data belongs to the ByteArray and may no longer be modified by the caller. The memory of data has to be dynamically allocated and will eventually be freed with free.

Do not use it if len is greater than G_MAXUINT. ByteArray stores the length of its data in guint, which may be shorter than gsize.

Since: 2.32

Adds the given data to the start of the ByteArray. The array will grow in size automatically if necessary.

Atomically increments the reference count of array by one. This function is thread-safe and may be called from any thread.

Since: 2.22

Removes the byte at the given index from a ByteArray. The following bytes are moved down one place.

Removes the byte at the given index from a ByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the ByteArray. But it is faster than byteArrayRemoveIndex.

Removes the given number of bytes starting at the given index from a ByteArray. The following elements are moved to close the gap.

Since: 2.4

Sets the size of the ByteArray, expanding it if necessary.

Creates a new ByteArray with reservedSize 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.

Sorts a byte array, using compareFunc which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if first arg is greater than second arg).

If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses.

Like byteArraySort, but the comparison function takes an extra user data argument.

Frees the data in the array and resets the size to zero, while the underlying array is preserved for use elsewhere and returned to the caller.

Since: 2.64

Atomically decrements the reference count of array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread.

Since: 2.22

Get the value of the “data” field. When overloading is enabled, this is equivalent to

get byteArray #data

Set the value of the “data” field. When overloading is enabled, this is equivalent to

set byteArray [ #data := value ]

Get the value of the “len” field. When overloading is enabled, this is equivalent to

get byteArray #len

Set the value of the “len” field. When overloading is enabled, this is equivalent to

set byteArray [ #len := value ]