Package ch.bailu.gtk.gio

Class PollableOutputStream

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.Interface
ch.bailu.gtk.gio.PollableOutputStream
All Implemented Interfaces:
PointerInterface
public class PollableOutputStream extends Interface
#GPollableOutputStream is implemented by #GOutputStreams that
can be polled for readiness to write. This can be used when
interfacing with a non-GIO API that expects
UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.

https://docs.gtk.org/gio/iface.PollableOutputStream.html

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • canPoll

      public boolean canPoll()
      Checks if @stream is actually pollable. Some classes may implement
      #GPollableOutputStream but have only certain instances of that
      class be pollable. If this method returns %FALSE, then the behavior
      of other #GPollableOutputStream methods is undefined.

      For any given stream, the value returned by this method is constant;
      a stream cannot switch from pollable to non-pollable or vice versa.
      Returns:
      %TRUE if @stream is pollable, %FALSE if not.

    • createSource

      public Source createSource(@Nullable Cancellable cancellable)
      Creates a #GSource that triggers when @stream can be written, or
      @cancellable is triggered or an error occurs. The callback on the
      source is of the #GPollableSourceFunc type.

      As with g_pollable_output_stream_is_writable(), it is possible that
      the stream may not actually be writable even after the source
      triggers, so you should use g_pollable_output_stream_write_nonblocking()
      rather than g_output_stream_write() from the callback.
      Parameters:
      cancellable - a #GCancellable, or %NULL
      Returns:
      a new #GSource

    • isWritable

      public boolean isWritable()
      Checks if @stream can be written.

      Note that some stream types may not be able to implement this 100%
      reliably, and it is possible that a call to g_output_stream_write()
      after this returns %TRUE would still block. To guarantee
      non-blocking behavior, you should always use
      g_pollable_output_stream_write_nonblocking(), which will return a
      %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
      Returns:
      %TRUE if @stream is writable, %FALSE if not. If an error has occurred on @stream, this will result in g_pollable_output_stream_is_writable() returning %TRUE, and the next attempt to write will return the error.

    • writeNonblocking

      public long writeNonblocking(@Nonnull Pointer buffer, long count, @Nullable Cancellable cancellable) throws AllocationError
      Attempts to write up to @count bytes from @buffer to @stream, as
      with g_output_stream_write(). If @stream is not currently writable,
      this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
      use g_pollable_output_stream_create_source() to create a #GSource
      that will be triggered when @stream is writable.

      Note that since this method never blocks, you cannot actually
      use @cancellable to cancel it. However, it will return an error
      if @cancellable has already been cancelled when you call, which
      may happen if you call this method after a source triggers due
      to having been cancelled.

      Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
      transports like D/TLS require that you re-send the same @buffer and
      @count in the next write call.
      Parameters:
      buffer - a buffer to write data from
      count - the number of bytes you want to write
      cancellable - a #GCancellable, or %NULL
      Returns:
      the number of bytes written, or -1 on error (including %G_IO_ERROR_WOULD_BLOCK).
      Throws:
      AllocationError

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