gio/org.gtkkn.bindings.gio/OutputStream

OutputStream

open class OutputStream(pointer: <Error class: unknown class><<Error class: unknown class>>)

#GOutputStream has functions to write to a stream (g_output_stream_write()), to close a stream (g_output_stream_close()) and to flush pending writes (g_output_stream_flush()).

To copy the content of an input stream to an output stream without manually handling the reads and writes, use g_output_stream_splice().

See the documentation for #GIOStream for details of thread safety of streaming APIs.

All of these functions have async variants too.

Skipped during bindings generation

parameter buffer: guint8
parameter buffer: guint8
parameter buffer: guint8
parameter bytes_written: bytes_written: Out parameter is not supported
parameter buffer: guint8
parameter vectors: OutputVector
parameter vectors: OutputVector
parameter vectors: OutputVector
parameter bytes_written: bytes_written: Out parameter is not supported
parameter vectors: OutputVector
parameter bytes_written: bytes_written: Out parameter is not supported

Inheritors

Constructors

OutputStream

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

Types

Companion

object Companion

Properties

gioOutputStreamPointer

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

Functions

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.

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.

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.

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.