Package ch.bailu.gtk.gst

Klasse Promise

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.gst.Promise
Alle implementierten Schnittstellen:
PointerInterface
public class Promise extends Record
The #GstPromise object implements the container for values that may
be available later. i.e. a Future or a Promise in
<https://en.wikipedia.org/wiki/Futures_and_promises>.
As with all Future/Promise-like functionality, there is the concept of the
producer of the value and the consumer of the value.

A #GstPromise is created with gst_promise_new() by the consumer and passed
to the producer to avoid thread safety issues with the change callback.
A #GstPromise can be replied to with a value (or an error) by the producer
with gst_promise_reply(). The exact value returned is defined by the API
contract of the producer and %NULL may be a valid reply.
gst_promise_interrupt() is for the consumer to
indicate to the producer that the value is not needed anymore and producing
that value can stop. The @GST_PROMISE_RESULT_EXPIRED state set by a call
to gst_promise_expire() indicates to the consumer that a value will never
be produced and is intended to be called by a third party that implements
some notion of message handling such as #GstBus.
A callback can also be installed at #GstPromise creation for
result changes with gst_promise_new_with_change_func().
The change callback can be used to chain #GstPromises's together as in the
following example. 
<!-- language="C" -->
 const GstStructure *reply;
 GstPromise *p;
 if (gst_promise_wait (promise) != GST_PROMISE_RESULT_REPLIED)
   return; // interrupted or expired value
 reply = gst_promise_get_reply (promise);
 if (error in reply)
   return; // propagate error
 p = gst_promise_new_with_change_func (another_promise_change_func, user_data, notify);
 pass p to promise-using API


Each #GstPromise starts out with a #GstPromiseResult of
%GST_PROMISE_RESULT_PENDING and only ever transitions once
into one of the other #GstPromiseResult's.

In order to support multi-threaded code, gst_promise_reply(),
gst_promise_interrupt() and gst_promise_expire() may all be from
different threads with some restrictions and the final result of the promise
is whichever call is made first. There are two restrictions on ordering:

1. That gst_promise_reply() and gst_promise_interrupt() cannot be called
after gst_promise_expire()
2. That gst_promise_reply() and gst_promise_interrupt()
cannot be called twice.

The change function set with gst_promise_new_with_change_func() is
called directly from either the gst_promise_reply(),
gst_promise_interrupt() or gst_promise_expire() and can be called
from an arbitrary thread. #GstPromise using APIs can restrict this to
a single thread or a subset of threads but that is entirely up to the API
that uses #GstPromise.

https://gstreamer.freedesktop.org/documentation/gstreamer/gi-index.html

  • Felddetails

    • PARENT

      public static final String PARENT
      parent #GstMiniObject
      Private field: direct-type
      Siehe auch:

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newWithChangeFuncPromise

      public static Promise newWithChangeFuncPromise(Promise.OnPromiseChangeFunc func, @Nullable Pointer user_data, Promise.OnDestroyNotify notify)
      @func will be called exactly once when transitioning out of
      %GST_PROMISE_RESULT_PENDING into any of the other #GstPromiseResult
      states.
      Parameter:
      func - a #GstPromiseChangeFunc to call
      user_data - argument to call @func with
      notify - notification function that @user_data is no longer needed
      Gibt zurück:
      a new #GstPromise

    • expire

      public void expire()
      Expire a @promise. This will wake up any waiters with
      %GST_PROMISE_RESULT_EXPIRED. Called by a message loop when the parent
      message is handled and/or destroyed (possibly unanswered).

    • getReply

      public Structure getReply()
      Retrieve the reply set on @promise. @promise must be in
      %GST_PROMISE_RESULT_REPLIED and the returned structure is owned by @promise
      Gibt zurück:
      The reply set on @promise

    • interrupt

      public void interrupt()
      Interrupt waiting for a @promise. This will wake up any waiters with
      %GST_PROMISE_RESULT_INTERRUPTED. Called when the consumer does not want
      the value produced anymore.

    • reply

      public void reply(@Nullable Structure s)
      Set a reply on @promise. This will wake up any waiters with
      %GST_PROMISE_RESULT_REPLIED. Called by the producer of the value to
      indicate success (or failure).

      If @promise has already been interrupted by the consumer, then this reply
      is not visible to the consumer.
      Parameter:
      s - a #GstStructure with the the reply contents

    • doWait

      public int doWait()
      Wait for @promise to move out of the %GST_PROMISE_RESULT_PENDING state.
      If @promise is not in %GST_PROMISE_RESULT_PENDING then it will return
      immediately with the current result.
      Gibt zurück:
      the result of the promise

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