Back to Seed Clases

Gio

Classes

Interfaces

Structs

Unions

Enums

GObject.Object
parent-child marker Gio.OutputStream
Gio.FilterOutputStream

Class Gio.FilterOutputStream

Import line:	Gio = imports.gi.Gio;
GIR File:	Gio-2.0.gir
C documentation:	GFilterOutputStream
Class :	FilterOutputStream
Subclasses:	Gio.BufferedOutputStream, Gio.ConverterOutputStream, Gio.DataOutputStream
Extends:	Gio.OutputStream

Base class for output stream implementations that perform some
kind of filtering operation on a base stream. Typical examples
of filtering operations are character set conversion, compression
and byte order flipping.

Properties
Properties		Defined By
	base_stream : Gio.OutputStream	Gio.FilterOutputStream
	base_stream : Gio.OutputStream read only	Gio.FilterOutputStream
	close_base_stream : gboolean	Gio.FilterOutputStream
	parent_instance : Gio.OutputStream read only	Gio.FilterOutputStream
	priv : Gio.OutputStreamPrivate read only	Gio.OutputStream

Methods / Constructors
Method / Constructor		Defined By
	new Gio.FilterOutputStream (Object *properties) Create a new Gio.FilterOutputStream Create a new Gio.FilterOutputStream Parameters: Object properties*
	clear_pending () : none Clears the pending flag on stream. Clears the pending flag on stream. Returns: none	Gio.OutputStream
	close (Cancellable *cancellable) : gboolean Closes the stream, releasing resources related to it. Closes the stream, releasing resources related to it. Once the stream is closed, all other operations will return G_IO_ERROR_CLOSED. Closing a stream multiple times will not return an error. Closing a stream will automatically flush any outstanding buffers in the stream. Streams will be automatically closed when the last reference is dropped, but you might want to call this function to make sure resources are released as early as possible. Some streams might keep the backing store of the stream (e.g. a file descriptor) open after the stream is closed. See the documentation for the individual stream for details. On failure the first error that happened will be reported, but the close operation will finish as much as possible. A stream that failed to close will still return G_IO_ERROR_CLOSED* for all operations. Still, it is important to check and report the error to the user, otherwise there might be a loss of data as all data might not be written. If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. Cancelling a close will still leave the stream closed, but there some streams can use a faster close that doesn't block to e.g. check errors. On cancellation (as with any error) there is no guarantee that all written data will reach the target. Parameters: Gio.Cancellable cancellable optional cancellable object Returns: gboolean TRUE on success, FALSE on failure	Gio.OutputStream
	close_async (gint32 *io_priority, Cancellable cancellable, Function callback, void *user_data) : none Requests an asynchronous close of the stream, releasing resources related to it. 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. For behaviour details see g_output_stream_close(). The asyncronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. Parameters: gint32 io_priority Required (not null) the io priority of the request. Gio.Cancellable cancellable optional cancellable object Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) callback to call when the request is satisfied void user_data Required (not null) the data to pass to callback function Returns: none	Gio.OutputStream
	close_finish (AsyncResult *result) : gboolean Closes an output stream. Closes an output stream. Parameters: Gio.AsyncResult result* Required (not null) a GAsyncResult. Returns: gboolean TRUE if stream was successfully closed, FALSE otherwise.	Gio.OutputStream
	flush (Cancellable *cancellable) : gboolean Flushed any outstanding buffers in the stream. Flushed any outstanding buffers in the stream. Will block during the operation. Closing the stream will implicitly cause a flush. This function is optional for inherited classes. If cancellable* is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. Parameters: Gio.Cancellable cancellable optional cancellable object Returns: gboolean TRUE on success, FALSE on error	Gio.OutputStream
	flush_async (gint32 *io_priority, Cancellable cancellable, Function callback, void *user_data) : none Flushes a stream asynchronously. Flushes a stream asynchronously. For behaviour details see g_output_stream_flush(). When the operation is finished callback* will be called. You can then call g_output_stream_flush_finish() to get the result of the operation. Parameters: gint32 io_priority Required (not null) the io priority of the request. Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) a GAsyncReadyCallback* to call when the request is satisfied void* user_data Required (not null) the data to pass to callback function Returns: none	Gio.OutputStream
	flush_finish (AsyncResult *result) : gboolean Finishes flushing an output stream. Finishes flushing an output stream. Parameters: Gio.AsyncResult result* Required (not null) a GAsyncResult. Returns: gboolean TRUE if flush operation suceeded, FALSE otherwise.	Gio.OutputStream
	get_base_stream () : Gio.OutputStream Gets the base stream for the filter stream. Gets the base stream for the filter stream. Returns: Gio.OutputStream a GOutputStream.	Gio.FilterOutputStream
	get_close_base_stream () : gboolean Returns whether the base stream will be closed when stream is closed. Returns whether the base stream will be closed when stream is closed. Returns: gboolean TRUE if the base stream will be closed.	Gio.FilterOutputStream
	has_pending () : gboolean Checks if an ouput stream has pending actions. Checks if an ouput stream has pending actions. Returns: gboolean TRUE if stream has pending actions.	Gio.OutputStream
	is_closed () : gboolean Checks if an output stream has already been closed. Checks if an output stream has already been closed. Returns: gboolean TRUE if stream is closed. FALSE otherwise.	Gio.OutputStream
	is_closing () : gboolean Checks if an output stream is being closed. 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. Returns: gboolean TRUE if stream is being closed. FALSE otherwise.	Gio.OutputStream
	set_close_base_stream (gboolean *close_base) : none Sets whether the base stream will be closed when stream* is closed. Sets whether the base stream will be closed when stream is closed. Parameters: gboolean close_base Required (not null) TRUE to close the base stream. Returns: none	Gio.FilterOutputStream
	set_pending () : gboolean Sets stream to have actions pending. Sets stream to have actions pending. If the pending flag is already set or stream is closed, it will return FALSE and set Returns: gboolean TRUE if pending was previously unset and is now set.	Gio.OutputStream
	splice (InputStream *source, OutputStreamSpliceFlags flags, Cancellable cancellable) : gint32 Splices an input stream into an output stream. Splices an input stream into an output stream. -1 if an error occurred. Parameters: Gio.InputStream source* Required (not null) a GInputStream. Gio.OutputStreamSpliceFlags flags Required (not null) a set of GOutputStreamSpliceFlags. Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Returns: gint32 a gssize containing the size of the data spliced, or	Gio.OutputStream
	splice_async (InputStream *source, OutputStreamSpliceFlags flags, gint32 io_priority, Cancellable cancellable, Function callback, void *user_data) : none Splices a stream asynchronously. 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. For the synchronous, blocking version of this function, see g_output_stream_splice(). Parameters: Gio.InputStream source Required (not null) a GInputStream. Gio.OutputStreamSpliceFlags flags Required (not null) a set of GOutputStreamSpliceFlags. gint32 io_priority Required (not null) the io priority of the request. Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) a GAsyncReadyCallback. void user_data Required (not null) user data passed to callback. Returns: none	Gio.OutputStream
	splice_finish (AsyncResult *result) : gint32 Finishes an asynchronous stream splice operation. Finishes an asynchronous stream splice operation. Parameters: Gio.AsyncResult result* Required (not null) a GAsyncResult. Returns: gint32 a gssize of the number of bytes spliced.	Gio.OutputStream
	write (String *buffer, guint32 count, Cancellable cancellable) : gint32 Tries to write count* bytes from buffer into the stream. Tries to write count bytes from buffer into the stream. Will block during the operation. If count is 0, returns 0 and does nothing. A value of count larger than G_MAXSSIZE will cause a G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written to the stream is returned. It is not an error if this is not the same as the requested size, as it can happen e.g. on a partial I/O error, or if there is not enough storage in the stream. All writes block until at least one byte is written or an error occurs; 0 is never returned (unless If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error. On error -1 is returned and error is set accordingly. Parameters: String buffer Required (not null) the buffer containing the data to write. guint32 count Required (not null) the number of bytes to write Gio.Cancellable cancellable optional cancellable object Returns: gint32 Number of bytes written, or -1 on error	Gio.OutputStream
	write_all (String *buffer, guint32 count, Object out_values, Cancellable cancellable) : gboolean Tries to write count* bytes from buffer into the stream. Tries to write count bytes from buffer into the stream. Will block during the operation. This function is similar to g_output_stream_write(), except it tries to write as many bytes as requested, only stopping on an error. On a successful write of count bytes, TRUE is returned, and bytes_written is set to count. If there is an error during the operation FALSE is returned and error is set to indicate the error status, bytes_written is updated to contain the number of bytes written into the stream before the error occurred. Parameters: String buffer Required (not null) the buffer containing the data to write. guint32 count Required (not null) the number of bytes to write Object out_values guint32 bytes_written Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Returns: gboolean TRUE on success, FALSE if there was an error	Gio.OutputStream
	write_async (String *buffer, guint32 count, gint32 io_priority, Cancellable cancellable, Function callback, void *user_data) : none Request an asynchronous write of count* bytes from buffer into the stream. 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. During an async request no other sync and async calls are allowed, and will result in G_IO_ERROR_PENDING errors. A value of count larger than G_MAXSSIZE will cause a G_IO_ERROR_INVALID_ARGUMENT error. On success, the number of bytes written will be passed to the requested size, as it can happen e.g. on a partial I/O error, but generally we try to write as many bytes as requested. You are guaranteed that this method will never fail with G_IO_ERROR_WOULD_BLOCK - if stream can't accept more data, the method will just wait until this changes. Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority. Default priority is G_PRIORITY_DEFAULT. The asyncronous methods have a default fallback that uses threads to implement asynchronicity, so they are optional for inheriting classes. However, if you override one you must override all. For the synchronous, blocking version of this function, see g_output_stream_write(). Parameters: String buffer Required (not null) the buffer containing the data to write. guint32 count Required (not null) the number of bytes to write gint32 io_priority Required (not null) the io priority of the request. Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) callback to call when the request is satisfied void user_data Required (not null) the data to pass to callback function Returns: none	Gio.OutputStream
	write_finish (AsyncResult *result) : gint32 Finishes a stream write operation. Finishes a stream write operation. Parameters: Gio.AsyncResult result* Required (not null) a GAsyncResult. Returns: gint32 a gssize containing the number of bytes written to the stream.	Gio.OutputStream

Events
None