gio/org.gtkkn.bindings.gio/UnixOutputStream

UnixOutputStream

open class UnixOutputStream(pointer: <Error class: unknown class><<Error class: unknown class>>) : OutputStream, FileDescriptorBased, PollableOutputStream

GUnixOutputStream implements class@Gio.OutputStream for writing to a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.)

Note that <gio/gunixoutputstream.h> belongs to the UNIX-specific GIO interfaces, thus you have to use the gio-unix-2.0.pc pkg-config file file or the GioUnix-2.0 GIR namespace when using it.

Constructors

UnixOutputStream

constructor(fd: Int, closeFd: Boolean)

Creates a new #GUnixOutputStream for the given @fd.

constructor(pointer: <Error class: unknown class><<Error class: unknown class>>)

Types

Companion

object Companion

Properties

closeFd

open var closeFd: Boolean

Whether to close the file descriptor when the stream is closed.

open val fd: Int

The file descriptor that the stream writes to.

gioFileDescriptorBasedPointer

open override val gioFileDescriptorBasedPointer: <Error class: unknown class><<Error class: unknown class>>

gioOutputStreamPointer

val gioOutputStreamPointer: <Error class: unknown class><<Error class: unknown class>>

gioPollableOutputStreamPointer

open override val gioPollableOutputStreamPointer: <Error class: unknown class><<Error class: unknown class>>

gioUnixOutputStreamPointer

val gioUnixOutputStreamPointer: <Error class: unknown class><<Error class: unknown class>>

Functions

canPoll

open fun canPoll(): Boolean

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.

clearPending

open fun clearPending()

Clears the pending flag on @stream.

open fun close(cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Closes the stream, releasing resources related to it.

closeAsync

open fun closeAsync(ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

Requests an asynchronous close of the stream, releasing resources related to it. When the operation is finished @callback will be called. You can then call g_output_stream_close_finish() to get the result of the operation.

closeFinish

open fun closeFinish(result: AsyncResult): <Error class: unknown class><Boolean>

Closes an output stream.

createSource

open fun createSource(cancellable: Cancellable? = null): <Error class: unknown class>

Creates a #GSource that triggers when @stream can be written, or

flush

open fun flush(cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Forces a write of all user-space buffered data for the given

flushAsync

open fun flushAsync(ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

Forces an asynchronous write of all user-space buffered data for the given @stream. For behaviour details see g_output_stream_flush().

flushFinish

open fun flushFinish(result: AsyncResult): <Error class: unknown class><Boolean>

Finishes flushing an output stream.

getCloseFd

open fun getCloseFd(): Boolean

Returns whether the file descriptor of @stream will be closed when the stream is closed.

getFd

open fun getFd(): Int

Gets the underlying file descriptor.

getFd_

open fun getFd_(): Int

Return the UNIX file descriptor that the stream writes to.

hasPending

open fun hasPending(): Boolean

Checks if an output stream has pending actions.

isClosed

open fun isClosed(): Boolean

Checks if an output stream has already been closed.

isClosing

open fun isClosing(): Boolean

Checks if an output stream is being closed. This can be used inside e.g. a flush implementation to see if the flush (or other i/o operation) is called from within the closing operation.

isWritable

open fun isWritable(): Boolean

Checks if @stream can be written.

setCloseFd

open fun setCloseFd(closeFd: Boolean)

Sets whether the file descriptor of @stream shall be closed when the stream is closed.

setPending

open fun setPending(): <Error class: unknown class><Boolean>

Sets @stream to have actions pending. If the pending flag is already set or @stream is closed, it will return false and set

splice

open fun splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable: Cancellable? = null): <Error class: unknown class><Long>

Splices an input stream into an output stream.

spliceAsync

open fun spliceAsync(source: InputStream, flags: OutputStreamSpliceFlags, ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

Splices a stream asynchronously. When the operation is finished @callback will be called. You can then call g_output_stream_splice_finish() to get the result of the operation.

spliceFinish

open fun spliceFinish(result: AsyncResult): <Error class: unknown class><Long>

Finishes an asynchronous stream splice operation.

writeBytes

open fun writeBytes(bytes: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Long>

A wrapper function for g_output_stream_write() which takes a #GBytes as input. This can be more convenient for use by language bindings or in other cases where the refcounted nature of #GBytes is helpful over a bare pointer interface.

writeBytesAsync

open fun writeBytesAsync(bytes: <Error class: unknown class>, ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

This function is similar to g_output_stream_write_async(), but takes a #GBytes as input. Due to the refcounted nature of #GBytes, this allows the stream to avoid taking a copy of the data.

writeBytesFinish

open fun writeBytesFinish(result: AsyncResult): <Error class: unknown class><Long>

Finishes a stream write-from-#GBytes operation.

writeFinish

open fun writeFinish(result: AsyncResult): <Error class: unknown class><Long>

Finishes a stream write operation.