GLib.ByteArray

record (struct)

Contains the public fields of a GByteArray.

Static functions

append

@staticmethod
def append(array: list[int], data: list[int]) -> list[int]

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

Parameters:

• array — a byte array
• data — the byte data to be added

free

@staticmethod
def free(array: list[int], free_segment: bool) -> list[int] | None

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

Parameters:

• array — a byte array
• free_segment — if true, the actual byte data is freed as well

free_to_bytes

@staticmethod
def free_to_bytes(array: list[int]) -> Bytes

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

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

This is identical to using Bytes.new_take and ByteArray.free together.

Parameters:

• array — a byte array

new

@staticmethod
def new() -> list[int]

Creates a new GByteArray with a reference count of 1.

new_take

@staticmethod
def new_take(data: list[int]) -> list[int]

Creates a byte array containing the data. After this call, data belongs to the GByteArray 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. GByteArray stores the length of its data in guint, which may be shorter than gsize.

Parameters:

• data — the byte data for the array

prepend

@staticmethod
def prepend(array: list[int], data: list[int]) -> list[int]

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

Parameters:

• array — a byte array
• data — the byte data to be added

ref

@staticmethod
def ref(array: list[int]) -> list[int]

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

Parameters:

• array — a byte array

remove_index

@staticmethod
def remove_index(array: list[int], index_: int) -> list[int]

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

Parameters:

• array — a byte array
• index_ — the index of the byte to remove

remove_index_fast

@staticmethod
def remove_index_fast(array: list[int], index_: int) -> list[int]

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 ByteArray.remove_index.

Parameters:

• array — a byte array
• index_ — the index of the byte to remove

remove_range

@staticmethod
def remove_range(array: list[int], index_: int, length: int) -> list[int]

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

Parameters:

• array — a byte array
• index_ — the index of the first byte to remove
• length — the number of bytes to remove

set_size

@staticmethod
def set_size(array: list[int], length: int) -> list[int]

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

Parameters:

• array — a byte array
• length — the new size of the GByteArray

sized_new

@staticmethod
def sized_new(reserved_size: int) -> list[int]

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.

Parameters:

• reserved_size — the number of bytes preallocated

sort

@staticmethod
def sort(array: list[int], compare_func: CompareFunc) -> None

Sorts a byte array, using compare_func 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.

Parameters:

• array — a byte array
• compare_func — the comparison function

sort_with_data

@staticmethod
def sort_with_data(array: list[int], compare_func: CompareDataFunc) -> None

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

Parameters:

• array — a byte array
• compare_func — the comparison function

steal

@staticmethod
def steal(array: list[int]) -> list[int]

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.

Parameters:

• array — a byte array

unref

@staticmethod
def unref(array: list[int]) -> None

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.

Parameters:

• array — a byte array

Properties

data

data: int  # read/write

len

len: int  # read/write