UnixOutputStream

#GUnixOutputStream implements #GOutputStream 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 when using it.

class UnixOutputStream : OutputStream , FileDescriptorBasedIF , PollableOutputStreamIF {

protected

GUnixOutputStream* gUnixOutputStream;

GUnixOutputStream* getUnixOutputStreamStruct(bool transferOwnership);

void* getStruct();

this(GUnixOutputStream* gUnixOutputStream, bool ownedRef);

mixin FileDescriptorBasedT!(GUnixOutputStream) ;

mixin PollableOutputStreamT!(GUnixOutputStream) ;

static GType getType();

this(int fd, bool closeFd);

bool getCloseFd();

int getFd();

void setCloseFd(bool closeFd);

}

Constructors

this this(GUnixOutputStream* gUnixOutputStream, bool ownedRef): Sets our main struct and passes it to the parent class.
this this(int fd, bool closeFd): Creates a new #GUnixOutputStream for the given @fd.

Members

Functions

getCloseFd bool getCloseFd(): Returns whether the file descriptor of @stream will be closed when the stream is closed.
getFd int getFd(): Return the UNIX file descriptor that the stream writes to.
getStruct void* getStruct(): the main Gtk struct as a void*
getUnixOutputStreamStruct GUnixOutputStream* getUnixOutputStreamStruct(bool transferOwnership): Get the main Gtk struct
setCloseFd void setCloseFd(bool closeFd): Sets whether the file descriptor of @stream shall be closed when the stream is closed.

Mixins

__anonymous mixin FileDescriptorBasedT!(GUnixOutputStream): Undocumented in source.
__anonymous mixin PollableOutputStreamT!(GUnixOutputStream): Undocumented in source.

Static functions

getType GType getType()

Variables

gUnixOutputStream GUnixOutputStream* gUnixOutputStream;: the main Gtk struct

Inherited Members

From OutputStream

gOutputStream GOutputStream* gOutputStream;: the main Gtk struct
getOutputStreamStruct GOutputStream* getOutputStreamStruct(bool transferOwnership): Get the main Gtk struct
getStruct void* getStruct(): the main Gtk struct as a void*
getType GType getType()
clearPending void clearPending(): Clears the pending flag on @stream.
close bool close(Cancellable cancellable): Closes the stream, releasing resources related to it.
closeAsync void closeAsync(int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): 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 bool closeFinish(AsyncResultIF result): Closes an output stream.
flush bool flush(Cancellable cancellable): Forces a write of all user-space buffered data for the given @stream. Will block during the operation. Closing the stream will implicitly cause a flush.
flushAsync void flushAsync(int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): Forces an asynchronous write of all user-space buffered data for the given @stream. For behaviour details see g_output_stream_flush().
flushFinish bool flushFinish(AsyncResultIF result): Finishes flushing an output stream.
hasPending bool hasPending(): Checks if an output stream has pending actions.
isClosed bool isClosed(): Checks if an output stream has already been closed.
isClosing bool isClosing(): 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 bool setPending(): Sets @stream to have actions pending. If the pending flag is already set or @stream is closed, it will return %FALSE and set @error.
splice ptrdiff_t splice(InputStream source, GOutputStreamSpliceFlags flags, Cancellable cancellable): Splices an input stream into an output stream.
spliceAsync void spliceAsync(InputStream source, GOutputStreamSpliceFlags flags, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): 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 ptrdiff_t spliceFinish(AsyncResultIF result): Finishes an asynchronous stream splice operation.
vprintf bool vprintf(size_t bytesWritten, Cancellable cancellable, ErrorG error, string format, void* args): This is a utility function around g_output_stream_write_all(). It uses g_strdup_vprintf() to turn @format and @args into a string that is then written to @stream.
write ptrdiff_t write(ubyte[] buffer, Cancellable cancellable): Tries to write @count bytes from @buffer into the stream. Will block during the operation.
writeAll bool writeAll(ubyte[] buffer, size_t bytesWritten, Cancellable cancellable): Tries to write @count bytes from @buffer into the stream. Will block during the operation.
writeAllAsync void writeAllAsync(ubyte[] buffer, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): Request an asynchronous write of @count bytes from @buffer into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_write_all_finish() to get the result of the operation.
writeAllFinish bool writeAllFinish(AsyncResultIF result, size_t bytesWritten): Finishes an asynchronous stream write operation started with g_output_stream_write_all_async().
writeAsync void writeAsync(ubyte[] buffer, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): Request an asynchronous write of @count bytes from @buffer into the stream. When the operation is finished @callback will be called. You can then call g_output_stream_write_finish() to get the result of the operation.
writeBytes ptrdiff_t writeBytes(Bytes bytes, Cancellable cancellable): 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 void writeBytesAsync(Bytes bytes, int ioPriority, Cancellable cancellable, GAsyncReadyCallback callback, void* userData): 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 ptrdiff_t writeBytesFinish(AsyncResultIF result): Finishes a stream write-from-#GBytes operation.
writeFinish ptrdiff_t writeFinish(AsyncResultIF result): Finishes a stream write operation.

From FileDescriptorBasedIF

getFileDescriptorBasedStruct GFileDescriptorBased* getFileDescriptorBasedStruct(bool transferOwnership): Get the main Gtk struct
getStruct void* getStruct(): the main Gtk struct as a void*
getType GType getType()
getFd int getFd(): Gets the underlying file descriptor.

From PollableOutputStreamIF

getPollableOutputStreamStruct GPollableOutputStream* getPollableOutputStreamStruct(bool transferOwnership): Get the main Gtk struct
getStruct void* getStruct(): the main Gtk struct as a void*
getType GType getType()
canPoll bool 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.
createSource Source createSource(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.
isWritable bool isWritable(): Checks if @stream can be written.
writeNonblocking ptrdiff_t writeNonblocking(ubyte[] buffer, Cancellable cancellable): 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.