MemoryInputStream

open class MemoryInputStream(pointer: <Error class: unknown class><<Error class: unknown class>>) : InputStream, PollableInputStream, Seekable

GMemoryInputStream is a class for using arbitrary memory chunks as input for GIO streaming input operations.

As of GLib 2.34, GMemoryInputStream implements iface@Gio.PollableInputStream.

Skipped during bindings generation

  • parameter data: Array parameter of type guint8 is not supported

  • parameter data: Array parameter of type guint8 is not supported

Constructors

Link copied to clipboard
constructor()

Creates a new empty #GMemoryInputStream.

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

Creates a new #GMemoryInputStream with data from the given @bytes.

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

Types

Link copied to clipboard
object Companion

Properties

Link copied to clipboard
val gioInputStreamPointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
val gioMemoryInputStreamPointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
open override val gioPollableInputStreamPointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
open override val gioSeekablePointer: <Error class: unknown class><<Error class: unknown class>>

Functions

Link copied to clipboard
open fun addBytes(bytes: <Error class: unknown class>)

Appends @bytes to data that can be read from the input stream.

Link copied to clipboard
open fun canPoll(): Boolean

Checks if @stream is actually pollable. Some classes may implement #GPollableInputStream but have only certain instances of that class be pollable. If this method returns false, then the behavior of other #GPollableInputStream methods is undefined.

Link copied to clipboard
open fun canSeek(): Boolean

Tests if the stream supports the #GSeekableIface.

Link copied to clipboard
open fun canTruncate(): Boolean

Tests if the length of the stream can be adjusted with g_seekable_truncate().

Link copied to clipboard
open fun clearPending()

Clears the pending flag on @stream.

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

Closes the stream, releasing resources related to it.

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

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

Link copied to clipboard
open fun closeFinish(result: AsyncResult): <Error class: unknown class><Boolean>

Finishes closing a stream asynchronously, started from g_input_stream_close_async().

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

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

Link copied to clipboard
open fun hasPending(): Boolean

Checks if an input stream has pending actions.

Link copied to clipboard
open fun isClosed(): Boolean

Checks if an input stream is closed.

Link copied to clipboard
open fun isReadable(): Boolean

Checks if @stream can be read.

Link copied to clipboard
open fun readBytes(count: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><<Error class: unknown class>>

Like g_input_stream_read(), this tries to read @count bytes from the stream in a blocking fashion. However, rather than reading into a user-supplied buffer, this will create a new #GBytes containing the data that was read. This may be easier to use from language bindings.

Link copied to clipboard
open fun readBytesAsync(count: <Error class: unknown class>, ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

Request an asynchronous read of @count bytes from the stream into a new #GBytes. When the operation is finished @callback will be called. You can then call g_input_stream_read_bytes_finish() to get the result of the operation.

Link copied to clipboard
open fun readBytesFinish(result: AsyncResult): <Error class: unknown class><<Error class: unknown class>>

Finishes an asynchronous stream read-into-#GBytes operation.

Link copied to clipboard
open fun readFinish(result: AsyncResult): <Error class: unknown class><Long>

Finishes an asynchronous stream read operation.

Link copied to clipboard
open fun seek(offset: Long, type: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Seeks in the stream by the given @offset, modified by @type.

Link copied to clipboard
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

Link copied to clipboard
open fun skip(count: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Long>

Tries to skip @count bytes from the stream. Will block during the operation.

Link copied to clipboard
open fun skipAsync(count: <Error class: unknown class>, ioPriority: Int, cancellable: Cancellable? = null, callback: AsyncReadyCallback)

Request an asynchronous skip of @count bytes from the stream. When the operation is finished @callback will be called. You can then call g_input_stream_skip_finish() to get the result of the operation.

Link copied to clipboard
open fun skipFinish(result: AsyncResult): <Error class: unknown class><Long>

Finishes a stream skip operation.

Link copied to clipboard
open fun tell(): Long

Tells the current position within the stream.

Link copied to clipboard
open fun truncate(offset: Long, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Sets the length of the stream to @offset. If the stream was previously larger than @offset, the extra data is discarded. If the stream was previously shorter than @offset, it is extended with NUL ('\0') bytes.