Package ch.bailu.gtk.glib

Klasse Bytes

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.glib.Bytes
Alle implementierten Schnittstellen:
PointerInterface
Bekannte direkte Unterklassen:
Bytes
public class Bytes extends Record
A simple reference counted data type representing an immutable sequence of
zero or more bytes from an unspecified origin.

The purpose of a `GBytes` is to keep the memory region that it holds
alive for as long as anyone holds a reference to the bytes. When
the last reference count is dropped, the memory is released. Multiple
unrelated callers can use byte data in the `GBytes` without coordinating
their activities, resting assured that the byte data will not change or
move while they hold a reference.

A `GBytes` can come from many different origins that may have
different procedures for freeing the memory region. Examples are
memory from [func@GLib.malloc], from memory slices, from a
[struct@GLib.MappedFile] or memory from other allocators.

`GBytes` work well as keys in [struct@GLib.HashTable]. Use
[method@GLib.Bytes.equal] and [method@GLib.Bytes.hash] as parameters to
[func@GLib.HashTable.new] or [func@GLib.HashTable.new_full].
`GBytes` can also be used as keys in a [struct@GLib.Tree] by passing the
[method@GLib.Bytes.compare] function to [ctor@GLib.Tree.new].

The data pointed to by this bytes must not be modified. For a mutable
array of bytes see [struct@GLib.ByteArray]. Use
[method@GLib.Bytes.unref_to_array] to create a mutable array for a `GBytes`
sequence. To create an immutable `GBytes` from a mutable
[struct@GLib.ByteArray], use the [func@GLib.ByteArray.free_to_bytes]
function.

https://docs.gtk.org/glib/struct.Bytes.html

  • Konstruktordetails

    • Bytes

      public Bytes(PointerContainer pointer)

    • Bytes

      public Bytes(@Nullable Pointer data, long size)
      Creates a new [struct@GLib.Bytes] from @data.

      @data is copied. If @size is 0, @data may be `NULL`.

      As an optimization, [ctor@GLib.Bytes.new] may avoid an extra allocation by
      copying the data within the resulting bytes structure if sufficiently small
      (since GLib 2.84).
      Parameter:
      data - the data to be used for the bytes
      size - the size of @data

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newStaticBytes

      public static Bytes newStaticBytes(@Nullable Pointer data, long size)
      Creates a new [struct@GLib.Bytes] from static data.

      @data must be static (ie: never modified or freed). It may be `NULL` if @size
      is 0.
      Parameter:
      data - the data to be used for the bytes
      size - the size of @data
      Gibt zurück:
      a new [struct@GLib.Bytes]

    • newTakeBytes

      public static Bytes newTakeBytes(@Nullable Pointer data, long size)
      Creates a new [struct@GLib.Bytes] from @data.

      After this call, @data belongs to the `GBytes` 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@GLib.free].

      For creating `GBytes` with memory from other allocators, see
      [ctor@GLib.Bytes.new_with_free_func].

      @data may be `NULL` if @size is 0.
      Parameter:
      data - the data to be used for the bytes
      size - the size of @data
      Gibt zurück:
      a new [struct@GLib.Bytes]

    • newWithFreeFuncBytes

      public static Bytes newWithFreeFuncBytes(@Nullable Pointer data, long size, Bytes.OnDestroyNotify free_func, @Nullable Pointer user_data)
      Creates a [struct@GLib.Bytes] from @data.

      When the last reference is dropped, @free_func will be called with the
      @user_data argument.

      @data must not be modified after this call is made until @free_func has
      been called to indicate that the bytes is no longer in use.

      @data may be `NULL` if @size is 0.
      Parameter:
      data - the data to be used for the bytes
      size - the size of @data
      free_func - the function to call to release the data
      user_data - data to pass to @free_func
      Gibt zurück:
      a new [struct@GLib.Bytes]

    • compare

      public int compare(@Nonnull Pointer bytes2)
      Compares the two [struct@GLib.Bytes] values.

      This function can be used to sort `GBytes` instances in lexicographical
      order.

      If @bytes1 and @bytes2 have different length but the shorter one is a
      prefix of the longer one then the shorter one is considered to be less than
      the longer one. Otherwise the first byte where both differ is used for
      comparison. If @bytes1 has a smaller value at that position it is
      considered less, otherwise greater than @bytes2.
      Parameter:
      bytes2 - a pointer to a [struct@GLib.Bytes] to compare with @bytes1
      Gibt zurück:
      a negative value if @bytes1 is less than @bytes2, a positive value if @bytes1 is greater than @bytes2, and zero if @bytes1 is equal to @bytes2

    • equal

      public boolean equal(@Nonnull Pointer bytes2)
      Compares the two [struct@GLib.Bytes] values being pointed to and returns
      `TRUE` if they are equal.

      This function can be passed to [func@GLib.HashTable.new] as the
      @key_equal_func parameter, when using non-`NULL` `GBytes` pointers as keys in
      a [struct@GLib.HashTable].
      Parameter:
      bytes2 - a pointer to a [struct@GLib.Bytes] to compare with @bytes1
      Gibt zurück:
      `TRUE` if the two keys match.

    • getData

      public Pointer getData(@Nullable Int64 size)
      Get the byte data in the [struct@GLib.Bytes].

      This data should not be modified.

      This function will always return the same pointer for a given `GBytes`.

      `NULL` may be returned if @size is 0. This is not guaranteed, as the `GBytes`
      may represent an empty string with @data non-`NULL` and @size as 0. `NULL`
      will not be returned if @size is non-zero.
      Parameter:
      size - location to return size of byte data
      Gibt zurück:
      a pointer to the byte data

    • getRegion

      public Pointer getRegion(long element_size, long offset, long n_elements)
      Gets a pointer to a region in @bytes.

      The region starts at @offset many bytes from the start of the data
      and contains @n_elements many elements of @element_size size.

      @n_elements may be zero, but @element_size must always be non-zero.
      Ideally, @element_size is a static constant (eg: `sizeof` a struct).

      This function does careful bounds checking (including checking for
      arithmetic overflows) and returns a non-`NULL` pointer if the
      specified region lies entirely within the @bytes. If the region is
      in some way out of range, or if an overflow has occurred, then `NULL`
      is returned.

      Note: it is possible to have a valid zero-size region. In this case,
      the returned pointer will be equal to the base pointer of the data of
      @bytes, plus @offset. This will be non-`NULL` except for the case
      where @bytes itself was a zero-sized region. Since it is unlikely
      that you will be using this function to check for a zero-sized region
      in a zero-sized @bytes, `NULL` effectively always means ‘error’.
      Parameter:
      element_size - a non-zero element size
      offset - an offset to the start of the region within the @bytes
      n_elements - the number of elements in the region
      Gibt zurück:
      the requested region, or `NULL` in case of an error

    • getSize

      public long getSize()
      Get the size of the byte data in the [struct@GLib.Bytes].

      This function will always return the same value for a given `GBytes`.
      Gibt zurück:
      the size

    • hash

      public int hash()
      Creates an integer hash code for the byte data in the [struct@GLib.Bytes].

      This function can be passed to [func@GLib.HashTable.new] as the
      @key_hash_func parameter, when using non-`NULL` `GBytes` pointers as keys in
      a [struct@GLib.HashTable].
      Gibt zurück:
      a hash value corresponding to the key.

    • newFromBytes

      public Bytes newFromBytes(long offset, long length)
      Creates a [struct@GLib.Bytes] which is a subsection of another `GBytes`.

      The @offset + @length may not be longer than the size of @bytes.

      A reference to @bytes will be held by the newly created `GBytes` until
      the byte data is no longer needed.

      Since 2.56, if @offset is 0 and @length matches the size of @bytes, then
      @bytes will be returned with the reference count incremented by 1. If @bytes
      is a slice of another `GBytes`, then the resulting `GBytes` will reference
      the same `GBytes` instead of @bytes. This allows consumers to simplify the
      usage of `GBytes` when asynchronously writing to streams.
      Parameter:
      offset - offset which subsection starts at
      length - length of subsection
      Gibt zurück:
      a new [struct@GLib.Bytes]

    • ref

      public Bytes ref()
      Increase the reference count on @bytes.
      Gibt zurück:
      the [struct@GLib.Bytes]

    • unref

      public void unref()
      Releases a reference on @bytes.

      This may result in the bytes being freed. If @bytes is `NULL`, it will
      return immediately.

    • unrefToArray

      public ByteArray unrefToArray()
      Unreferences the bytes, and returns a new mutable [struct@GLib.ByteArray]
      containing the same byte data.

      As an optimization, the byte data is transferred to the array without copying
      if this was the last reference to @bytes and @bytes was created with
      [ctor@GLib.Bytes.new], [ctor@GLib.Bytes.new_take] or
      [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size
      [struct@GLib.Bytes] may internalize within its allocation. In all other cases
      the data is copied.

      Do not use it if @bytes contains more than %G_MAXUINT
      bytes. [struct@GLib.ByteArray] stores the length of its data in `guint`,
      which may be shorter than `gsize`, that @bytes is using.
      Gibt zurück:
      a new mutable [struct@GLib.ByteArray] containing the same byte data

    • unrefToData

      public Pointer unrefToData(@Nonnull Int64 size)
      Unreferences the bytes, and returns a pointer the same byte data
      contents.

      As an optimization, the byte data is returned without copying if this was
      the last reference to @bytes and @bytes was created with
      [ctor@GLib.Bytes.new], [ctor@GLib.Bytes.new_take] or
      [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size
      [struct@GLib.Bytes] may internalize within its allocation. In all other cases
      the data is copied.
      Parameter:
      size - location to place the length of the returned data
      Gibt zurück:
      a pointer to the same byte data, which should be freed with [func@GLib.free]

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()