Package ch.bailu.gtk.glib

Class PtrArray

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.glib.PtrArray
All Implemented Interfaces:
PointerInterface
public class PtrArray extends Record
Contains the public fields of a pointer array.

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

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • add

      public static void add(@Nonnull PtrArray array, @Nullable Pointer data)
      Adds a pointer to the end of the pointer array. The array will grow
      in size automatically if necessary.
      Parameters:
      array - a #GPtrArray
      data - the pointer to add

    • copy

      public static PtrArray copy(@Nonnull PtrArray array, PtrArray.OnCopyFunc func, @Nullable Pointer user_data)
      Makes a full (deep) copy of a #GPtrArray.

      @func, as a #GCopyFunc, takes two arguments, the data to be copied
      and a @user_data pointer. On common processor architectures, it's safe to
      pass %NULL as @user_data if the copy function takes only one argument. You
      may get compiler warnings from this though if compiling with GCC’s
      `-Wcast-function-type` warning.

      If @func is %NULL, then only the pointers (and not what they are
      pointing to) are copied to the new #GPtrArray.

      The copy of @array will have the same #GDestroyNotify for its elements as
      @array. The copy will also be %NULL terminated if (and only if) the source
      array is.
      Parameters:
      array - #GPtrArray to duplicate
      func - a copy function used to copy every element in the array
      user_data - user data passed to the copy function @func, or %NULL
      Returns:
      a deep copy of the initial #GPtrArray.

    • extend

      public static void extend(@Nonnull PtrArray array_to_extend, @Nonnull PtrArray array, PtrArray.OnCopyFunc func, @Nullable Pointer user_data)
      Adds all pointers of @array to the end of the array @array_to_extend.
      The array will grow in size automatically if needed. @array_to_extend is
      modified in-place.

      @func, as a #GCopyFunc, takes two arguments, the data to be copied
      and a @user_data pointer. On common processor architectures, it's safe to
      pass %NULL as @user_data if the copy function takes only one argument. You
      may get compiler warnings from this though if compiling with GCC’s
      `-Wcast-function-type` warning.

      If @func is %NULL, then only the pointers (and not what they are
      pointing to) are copied to the new #GPtrArray.

      Whether @array_to_extend is %NULL terminated stays unchanged by this function.
      Parameters:
      array_to_extend - a #GPtrArray.
      array - a #GPtrArray to add to the end of @array_to_extend.
      func - a copy function used to copy every element in the array
      user_data - user data passed to the copy function @func, or %NULL

    • extendAndSteal

      public static void extendAndSteal(@Nonnull PtrArray array_to_extend, @Nonnull PtrArray array)
      Adds all the pointers in @array to the end of @array_to_extend, transferring
      ownership of each element from @array to @array_to_extend and modifying
      @array_to_extend in-place. @array is then freed.

      As with g_ptr_array_free(), @array will be destroyed if its reference count
      is 1. If its reference count is higher, it will be decremented and the
      length of @array set to zero.
      Parameters:
      array_to_extend - a #GPtrArray.
      array - a #GPtrArray to add to the end of @array_to_extend.

    • foreach

      public static void foreach(@Nonnull PtrArray array, PtrArray.OnFunc func, @Nullable Pointer user_data)
      Calls a function for each element of a #GPtrArray. @func must not
      add elements to or remove elements from the array.
      Parameters:
      array - a #GPtrArray
      func - the function to call for each array element
      user_data - user data to pass to the function

    • insert

      public static void insert(@Nonnull PtrArray array, int index_, @Nullable Pointer data)
      Inserts an element into the pointer array at the given index. The
      array will grow in size automatically if necessary.
      Parameters:
      array - a #GPtrArray
      index_ - the index to place the new element at, or -1 to append
      data - the pointer to add.

    • isNullTerminated

      public static boolean isNullTerminated(@Nonnull PtrArray array)
      Gets whether the @array was constructed as %NULL-terminated.

      This will only return %TRUE for arrays constructed by passing %TRUE to the
      `null_terminated` argument of g_ptr_array_new_null_terminated(). It will not
      return %TRUE for normal arrays which have had a %NULL element appended to
      them.
      Parameters:
      array - the #GPtrArray
      Returns:
      %TRUE if the array is made to be %NULL terminated.

    • _new

      public static PtrArray _new()
      Creates a new #GPtrArray with a reference count of 1.
      Returns:
      the new #GPtrArray

    • newFull

      public static PtrArray newFull(int reserved_size, PtrArray.OnDestroyNotify element_free_func)
      Creates a new #GPtrArray with @reserved_size pointers preallocated
      and a reference count of 1. This avoids frequent reallocation, if
      you are going to add many pointers to the array. Note however that
      the size of the array is still 0. It also set @element_free_func
      for freeing each element when the array is destroyed either via
      g_ptr_array_unref(), when g_ptr_array_free() is called with
      @free_segment set to %TRUE or when removing elements.
      Parameters:
      reserved_size - number of pointers preallocated
      element_free_func - A function to free elements with destroy @array or %NULL
      Returns:
      A new #GPtrArray

    • newNullTerminated

      public static PtrArray newNullTerminated(int reserved_size, PtrArray.OnDestroyNotify element_free_func, boolean null_terminated)
      Like g_ptr_array_new_full() but also allows to set the array to
      be %NULL terminated. A %NULL terminated pointer array has an
      additional %NULL pointer after the last element, beyond the
      current length.

      #GPtrArray created by other constructors are not automatically %NULL
      terminated.

      Note that if the @array's length is zero and currently no
      data array is allocated, then pdata will still be %NULL.
      %GPtrArray will only %NULL terminate pdata, if an actual
      array is allocated. It does not guarantee that an array
      is always allocated. In other words, if the length is zero,
      then pdata may either point to a %NULL terminated array of length
      zero or be %NULL.
      Parameters:
      reserved_size - number of pointers preallocated. If @null_terminated is %TRUE, the actually allocated buffer size is @reserved_size plus 1, unless @reserved_size is zero, in which case no initial buffer gets allocated.
      element_free_func - A function to free elements with destroy @array or %NULL
      null_terminated - whether to make the array as %NULL terminated.
      Returns:
      A new #GPtrArray

    • newWithFreeFunc

      public static PtrArray newWithFreeFunc(PtrArray.OnDestroyNotify element_free_func)
      Creates a new #GPtrArray with a reference count of 1 and use
      @element_free_func for freeing each element when the array is destroyed
      either via g_ptr_array_unref(), when g_ptr_array_free() is called with
      @free_segment set to %TRUE or when removing elements.
      Parameters:
      element_free_func - A function to free elements with destroy @array or %NULL
      Returns:
      A new #GPtrArray

    • ref

      public static PtrArray ref(@Nonnull PtrArray array)
      Atomically increments the reference count of @array by one.
      This function is thread-safe and may be called from any thread.
      Parameters:
      array - a #GPtrArray
      Returns:
      The passed in #GPtrArray

    • remove

      public static boolean remove(@Nonnull PtrArray array, @Nullable Pointer data)
      Removes the first occurrence of the given pointer from the pointer
      array. The following elements are moved down one place. If @array
      has a non-%NULL #GDestroyNotify function it is called for the
      removed element.

      It returns %TRUE if the pointer was removed, or %FALSE if the
      pointer was not found.
      Parameters:
      array - a #GPtrArray
      data - the pointer to remove
      Returns:
      %TRUE if the pointer is removed, %FALSE if the pointer is not found in the array

    • removeFast

      public static boolean removeFast(@Nonnull PtrArray array, @Nullable Pointer data)
      Removes the first occurrence of the given pointer from the pointer
      array. The last element in the array is used to fill in the space,
      so this function does not preserve the order of the array. But it
      is faster than g_ptr_array_remove(). If @array has a non-%NULL
      #GDestroyNotify function it is called for the removed element.

      It returns %TRUE if the pointer was removed, or %FALSE if the
      pointer was not found.
      Parameters:
      array - a #GPtrArray
      data - the pointer to remove
      Returns:
      %TRUE if the pointer was found in the array

    • removeIndex

      public static Pointer removeIndex(@Nonnull PtrArray array, int index_)
      Removes the pointer at the given index from the pointer array.
      The following elements are moved down one place. If @array has
      a non-%NULL #GDestroyNotify function it is called for the removed
      element. If so, the return value from this function will potentially point
      to freed memory (depending on the #GDestroyNotify implementation).
      Parameters:
      array - a #GPtrArray
      index_ - the index of the pointer to remove
      Returns:
      the pointer which was removed

    • removeIndexFast

      public static Pointer removeIndexFast(@Nonnull PtrArray array, int index_)
      Removes the pointer at the given index from the pointer array.
      The last element in the array is used to fill in the space, so
      this function does not preserve the order of the array. But it
      is faster than g_ptr_array_remove_index(). If @array has a non-%NULL
      #GDestroyNotify function it is called for the removed element. If so, the
      return value from this function will potentially point to freed memory
      (depending on the #GDestroyNotify implementation).
      Parameters:
      array - a #GPtrArray
      index_ - the index of the pointer to remove
      Returns:
      the pointer which was removed

    • removeRange

      public static PtrArray removeRange(@Nonnull PtrArray array, int index_, int length)
      Removes the given number of pointers starting at the given index
      from a #GPtrArray. The following elements are moved to close the
      gap. If @array has a non-%NULL #GDestroyNotify function it is
      called for the removed elements.
      Parameters:
      array - a @GPtrArray
      index_ - the index of the first pointer to remove
      length - the number of pointers to remove
      Returns:
      the @array

    • setFreeFunc

      public static void setFreeFunc(@Nonnull PtrArray array, PtrArray.OnDestroyNotify element_free_func)
      Sets a function for freeing each element when @array is destroyed
      either via g_ptr_array_unref(), when g_ptr_array_free() is called
      with @free_segment set to %TRUE or when removing elements.
      Parameters:
      array - A #GPtrArray
      element_free_func - A function to free elements with destroy @array or %NULL

    • setSize

      public static void setSize(@Nonnull PtrArray array, int length)
      Sets the size of the array. When making the array larger,
      newly-added elements will be set to %NULL. When making it smaller,
      if @array has a non-%NULL #GDestroyNotify function then it will be
      called for the removed elements.
      Parameters:
      array - a #GPtrArray
      length - the new length of the pointer array

    • sizedNew

      public static PtrArray sizedNew(int reserved_size)
      Creates a new #GPtrArray with @reserved_size pointers preallocated
      and a reference count of 1. This avoids frequent reallocation, if
      you are going to add many pointers to the array. Note however that
      the size of the array is still 0.
      Parameters:
      reserved_size - number of pointers preallocated
      Returns:
      the new #GPtrArray

    • sort

      public static void sort(@Nonnull PtrArray array, PtrArray.OnCompareFunc compare_func)
      Sorts the 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 irst arg is
      greater than second arg).

      Note that the comparison function for g_ptr_array_sort() doesn't
      take the pointers from the array as arguments, it takes pointers to
      the pointers in the array. Here is a full example of usage: 
      <!-- language="C" -->
 typedef struct
 {
   gchar *name;
   gint size;
 } FileListEntry;
 
 static gint
 sort_filelist (gconstpointer a, gconstpointer b)
 {
   const FileListEntry *entry1 = *((FileListEntry **) a);
   const FileListEntry *entry2 = *((FileListEntry **) b);
 
   return g_ascii_strcasecmp (entry1->name, entry2->name);
 }
 
 …
 g_autoptr (GPtrArray) file_list = NULL;
 
 // initialize file_list array and load with many FileListEntry entries
 ...
 // now sort it with
 g_ptr_array_sort (file_list, sort_filelist);


      This is guaranteed to be a stable sort since version 2.32.
      Parameters:
      array - a #GPtrArray
      compare_func - comparison function

    • sortWithData

      public static void sortWithData(@Nonnull PtrArray array, PtrArray.OnCompareDataFunc compare_func, @Nullable Pointer user_data)
      Like g_ptr_array_sort(), but the comparison function has an extra
      user data argument.

      Note that the comparison function for g_ptr_array_sort_with_data()
      doesn't take the pointers from the array as arguments, it takes
      pointers to the pointers in the array. Here is a full example of use: 
      <!-- language="C" -->
 typedef enum { SORT_NAME, SORT_SIZE } SortMode;
 
 typedef struct
 {
   gchar *name;
   gint size;
 } FileListEntry;
 
 static gint
 sort_filelist (gconstpointer a, gconstpointer b, gpointer user_data)
 {
   gint order;
   const SortMode sort_mode = GPOINTER_TO_INT (user_data);
   const FileListEntry *entry1 = *((FileListEntry **) a);
   const FileListEntry *entry2 = *((FileListEntry **) b);
 
   switch (sort_mode)
     {
     case SORT_NAME:
       order = g_ascii_strcasecmp (entry1->name, entry2->name);
       break;
     case SORT_SIZE:
       order = entry1->size - entry2->size;
       break;
     default:
       order = 0;
       break;
     }
   return order;
 }
 
 ...
 g_autoptr (GPtrArray) file_list = NULL;
 SortMode sort_mode;
 
 // initialize file_list array and load with many FileListEntry entries
 ...
 // now sort it with
 sort_mode = SORT_NAME;
 g_ptr_array_sort_with_data (file_list,
                             sort_filelist,
                             GINT_TO_POINTER (sort_mode));


      This is guaranteed to be a stable sort since version 2.32.
      Parameters:
      array - a #GPtrArray
      compare_func - comparison function
      user_data - data to pass to @compare_func

    • stealIndex

      public static Pointer stealIndex(@Nonnull PtrArray array, int index_)
      Removes the pointer at the given index from the pointer array.
      The following elements are moved down one place. The #GDestroyNotify for
      @array is *not* called on the removed element; ownership is transferred to
      the caller of this function.
      Parameters:
      array - a #GPtrArray
      index_ - the index of the pointer to steal
      Returns:
      the pointer which was removed

    • stealIndexFast

      public static Pointer stealIndexFast(@Nonnull PtrArray array, int index_)
      Removes the pointer at the given index from the pointer array.
      The last element in the array is used to fill in the space, so
      this function does not preserve the order of the array. But it
      is faster than g_ptr_array_steal_index(). The #GDestroyNotify for @array is
      *not* called on the removed element; ownership is transferred to the caller
      of this function.
      Parameters:
      array - a #GPtrArray
      index_ - the index of the pointer to steal
      Returns:
      the pointer which was removed

    • unref

      public static void unref(@Nonnull PtrArray array)
      Atomically decrements the reference count of @array by one. If the
      reference count drops to 0, the effect is the same as calling
      g_ptr_array_free() with @free_segment set to %TRUE. This function
      is thread-safe and may be called from any thread.
      Parameters:
      array - A #GPtrArray

    • 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()