Package ch.bailu.gtk.glib

Klasse Once

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.glib.Once
Alle implementierten Schnittstellen:
PointerInterface
public class Once extends Record
A #GOnce struct controls a one-time initialization function. Any
one-time initialization function must have its own unique #GOnce
struct.

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

  • Felddetails

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • setFieldStatus

      public void setFieldStatus(int status)
      the status of the #GOnce

    • getFieldStatus

      public int getFieldStatus()
      the status of the #GOnce

    • impl

      public Pointer impl(Once.OnThreadFunc func, @Nullable Pointer arg)
      Parameter:
      func -
      arg -
      Gibt zurück:

    • initEnter

      public static boolean initEnter(@Nonnull Pointer location)
      Function to be called when starting a critical initialization
      section. The argument @location must point to a static
      0-initialized variable that will be set to a value other than 0 at
      the end of the initialization section. In combination with
      g_once_init_leave() and the unique address @value_location, it can
      be ensured that an initialization section will be executed only once
      during a program's life time, and that concurrent threads are
      blocked until initialization completed. To be used in constructs
      like this: 
      <!-- language="C" -->
   static gsize initialization_value = 0;
 
   if (g_once_init_enter (&initialization_value))
     {
       gsize setup_value = 42; // initialization code here
 
       g_once_init_leave (&initialization_value, setup_value);
     }
 
   // use initialization_value here


      While @location has a `volatile` qualifier, this is a historical artifact and
      the pointer passed to it should not be `volatile`.
      Parameter:
      location - location of a static initializable variable containing 0
      Gibt zurück:
      %TRUE if the initialization section should be entered, %FALSE and blocks otherwise

    • initEnterPointer

      public static boolean initEnterPointer(@Nonnull Pointer location)
      This functions behaves in the same way as g_once_init_enter(), but can
      can be used to initialize pointers (or #guintptr) instead of #gsize. 
      <!-- language="C" -->
   static MyStruct *interesting_struct = NULL;
 
   if (g_once_init_enter_pointer (&interesting_struct))
     {
       MyStruct *setup_value = allocate_my_struct (); // initialization code here
 
       g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value));
     }
 
   // use interesting_struct here
      Parameter:
      location - location of a static initializable variable containing `NULL`
      Gibt zurück:
      %TRUE if the initialization section should be entered, %FALSE and blocks otherwise

    • initLeave

      public static void initLeave(@Nonnull Pointer location, long result)
      Counterpart to g_once_init_enter(). Expects a location of a static
      0-initialized initialization variable, and an initialization value
      other than 0. Sets the variable to the initialization value, and
      releases concurrent threads blocking in g_once_init_enter() on this
      initialization variable.

      While @location has a `volatile` qualifier, this is a historical artifact and
      the pointer passed to it should not be `volatile`.
      Parameter:
      location - location of a static initializable variable containing 0
      result - new non-0 value for `*value_location`

    • initLeavePointer

      public static void initLeavePointer(@Nonnull Pointer location, @Nullable Pointer result)
      Counterpart to g_once_init_enter_pointer(). Expects a location of a static
      `NULL`-initialized initialization variable, and an initialization value
      other than `NULL`. Sets the variable to the initialization value, and
      releases concurrent threads blocking in g_once_init_enter_pointer() on this
      initialization variable.

      This functions behaves in the same way as g_once_init_leave(), but
      can be used to initialize pointers (or #guintptr) instead of #gsize.
      Parameter:
      location - location of a static initializable variable containing `NULL`
      result - new non-`NULL` value for `*location`