:right-sidebar: True

ByteArray
===================================================================

.. currentmodule:: gi.repository.GLib





.. class:: ByteArray(*args, **kwargs)
   :no-contents-entry:






Contains the public fields of a GByteArray.




Methods
-------

.. rst-class:: interim-class

.. class:: ByteArray
   :no-index:


   .. classmethod:: append(data: int, len: int) -> list[int]

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






      :param data: the byte data to be added

      :param len: the number of bytes to add




   .. classmethod:: free(free_segment: bool) -> int

      Frees the memory allocated by the ``GByteArray``. If ``free_segment`` is
      :const:`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.






      :param free_segment: if :const:`True` the actual byte data is freed as well




   .. classmethod:: free_to_bytes() -> ~gi.repository.GLib.Bytes

      Transfers the data from the ``GByteArray`` into a new immutable :obj:`~gi.repository.GLib.Bytes`\.

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

      This is identical to using :func:`~gi.repository.GLib.Bytes.new_take` and :func:`~gi.repository.GLib.ByteArray.free`
      together.


      .. versionadded:: 2.32








   .. classmethod:: new() -> list[int]

      Creates a new ``GByteArray`` with a reference count of 1.









   .. classmethod:: new_take() -> 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 :func:`~gi.repository.GLib.free`.

      Do not use it if ``len`` is greater than %G_MAXUINT. ``GByteArray``
      stores the length of its data in :obj:`int`, which may be shorter than
      :obj:`~gi.repository.gsize`\.


      .. versionadded:: 2.32








   .. classmethod:: prepend(data: int, len: int) -> list[int]

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






      :param data: the byte data to be added

      :param len: the number of bytes to add




   .. classmethod:: remove_index(index_: int) -> list[int]

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






      :param index_: the index of the byte to remove




   .. classmethod:: remove_index_fast(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 :func:`~gi.repository.GLib.ByteArray.remove_index`.






      :param index_: the index of the byte to remove




   .. classmethod:: remove_range(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.


      .. versionadded:: 2.4





      :param index_: the index of the first byte to remove

      :param length: the number of bytes to remove




   .. classmethod:: set_size(length: int) -> list[int]

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






      :param length: the new size of the ``GByteArray``




   .. classmethod:: sized_new() -> 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.









   .. classmethod:: sort(compare_func: ~typing.Callable[[~typing.Any, ~typing.Any], int]) -> 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.






      :param compare_func: comparison function




   .. classmethod:: sort_with_data(compare_func: ~typing.Callable[[~typing.Any, ~typing.Any, ~typing.Any], int], user_data: ~typing.Any = None) -> None

      Like :func:`~gi.repository.GLib.ByteArray.sort`, but the comparison function takes an extra
      user data argument.






      :param compare_func: comparison function

      :param user_data: data to pass to ``compare_func``














Fields
------

.. rst-class:: interim-class

.. class:: ByteArray
   :no-index:
   

   .. attribute:: data

      A pointer to the element data. The data may be moved as
          elements are added to the ``GByteArray``






   .. attribute:: len

      The number of elements in the ``GByteArray``