[647:14] static extends: object
Alternate constructors for GIOChannel. Usage:
GIOChannelCtors.<name>(...). The primary constructor lives
directly on GIOChannel.
newFile (string filename, string mode)
Open a file @filename as a #GIOChannel using mode @mode. This channel will be closed when the last reference to it is dropped, so there is no need to call g_io_channel_close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed).
filename is A string containing the name of a file.mode is One of "r", "w", "a", "r+", "w+", "a+". These have the same meaning as in fopen().A new GIOChannel.[41:7] extends: object
The GIOChannel data type aims to provide a portable method for using file
descriptors, pipes, and sockets, and integrating them into the main event
loop (see [struct@GLib.MainContext]). Currently, full support is available on
UNIX platforms; support for Windows is only partially complete. To create a
new GIOChannel on UNIX systems use [ctor@GLib.IOChannel.unix_new]. This
works for plain file descriptors, pipes and sockets. Alternatively, a channel
can be created for a file in a system independent manner using
[ctor@GLib.IOChannel.new_file]. Once a GIOChannel has been created, it can
be used in a generic manner with the functions
[method@GLib.IOChannel.read_chars], [method@GLib.IOChannel.write_chars],
[method@GLib.IOChannel.seek_position], and [method@GLib.IOChannel.shutdown].
To add a GIOChannel to the main event loop, use [func@GLib.io_add_watch] or
[func@GLib.io_add_watch_full]. Here you specify which events you are
interested in on the GIOChannel, and provide a function to be called
whenever these events occur. GIOChannel instances are created with an
initial reference count of 1. [method@GLib.IOChannel.ref] and
[method@GLib.IOChannel.unref] can be used to increment or decrement the
reference count respectively. When the reference count falls to 0, the
GIOChannel is freed. (Though it isn’t closed automatically, unless it was
created using [ctor@GLib.IOChannel.new_file].) Using [func@GLib.io_add_watch]
or [func@GLib.io_add_watch_full] increments a channel’s reference count. The
new functions [method@GLib.IOChannel.read_chars],
[method@GLib.IOChannel.read_line], [method@GLib.IOChannel.read_line_string],
[method@GLib.IOChannel.read_to_end], [method@GLib.IOChannel.write_chars],
[method@GLib.IOChannel.seek_position], and [method@GLib.IOChannel.flush]
should not be mixed with the deprecated functions
[method@GLib.IOChannel.read], [method@GLib.IOChannel.write], and
[method@GLib.IOChannel.seek] on the same channel.
GIOChannel (fd = null)
Creates a new #GIOChannel given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets. The returned #GIOChannel has a reference count of 1. The default encoding for #GIOChannel is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see g_get_charset()) with the g_io_channel_set_encoding() function. By default, the fd passed will not be closed when the final reference to the #GIOChannel data structure is dropped. If you want to read raw binary data without interpretation, then call the g_io_channel_set_encoding() function with %NULL for the encoding argument. This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean.
fd is a file descriptor..toNativeHandle (Source)
Normalizes a constructor argument into a raw pointer carrier. Accepts a raw NativeHandle, a raw NativeBuffer returned from
fn.call(...), another generated wrapper exposinghandle(), or null. Returns null when the argument carries no pointer.
Source is the raw handle, raw buffer, wrapper, or null.A raw pointer carrier or null when no pointer is present.getLib ()
Returns the opened native library for this generated wrapper.
The opened native library.handle ()
Returns the wrapped NativeHandle.
The wrapped NativeHandle.isNull ()
Returns true when the wrapped handle is null.
A bool.describe ()
Returns a small string for debugging generated wrappers.
A string.close ()
Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using g_io_channel_unref().
None.flush ()
Flushes the write buffer for the GIOChannel.
the status of the operation: One of %G_IO_STATUS_NORMAL, %G_IO_STATUS_AGAIN, or %G_IO_STATUS_ERROR..get_buffer_condition ()
This function returns a #GIOCondition depending on whether there is data to be read/space to write data in the internal buffers in the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.
A #GIOCondition.get_buffer_size ()
Gets the buffer size.
the size of the buffer..get_buffered ()
Returns whether @channel is buffered.
%TRUE if the @channel is buffered..get_close_on_unref ()
Returns whether the file/socket/whatever associated with @channel will be closed when @channel receives its final unref and is destroyed. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels.
%TRUE if the channel will be closed, %FALSE otherwise..get_encoding ()
Gets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The encoding %NULL makes the channel safe for binary data.
A string containing the encoding, this string is owned by GLib and must not be freed..get_flags ()
Gets the current flags for a #GIOChannel, including read-only flags such as %G_IO_FLAG_IS_READABLE. The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX shutdown() function), the user should immediately call g_io_channel_get_flags() to update the internal values of these flags.
the flags which are set on the channel.get_line_term ()
This returns the string that #GIOChannel uses to determine where in the file a line break occurs. A value of %NULL indicates autodetection. Since 2.84, the return value is always nul-terminated.
length is a location to return the length of the line terminator.The line termination string. This value is owned by GLib and must not be freed..init ()
Initializes a #GIOChannel struct. This is called by each of the above functions when creating a #GIOChannel, and so is not often needed by the application programmer (unless you are creating a new type of #GIOChannel).
None.read (string buf, int count, int bytes_read)
Reads data from a #GIOChannel.
buf is a buffer to read the data into (which should be at least count bytes long).count is the number of bytes to read from the #GIOChannel.bytes_read is returns the number of bytes actually read.%G_IO_ERROR_NONE if the operation was successful..read_chars (int count)
Replacement for g_io_channel_read() with the new API.
buf is a buffer to read data into.count is the size of the buffer. Note that the buffer may not be completely filled even if there is data in the buffer if the remaining data is not a complete character..bytes_read is The number of bytes read. This may be zero even on success if count < 6 and the channel's encoding is non-%NULL. This indicates that the next UTF-8 character is too wide for the buffer..the status of the operation..read_line ()
Reads a line, including the terminating character(s), from a #GIOChannel into a newly-allocated string. @str_return will contain allocated memory if the return is %G_IO_STATUS_NORMAL.
str_return is The line read from the #GIOChannel, including the line terminator. This data should be freed with g_free() when no longer needed. This is a nul-terminated string. If a @length of zero is returned, this will be %NULL instead..length is location to store length of the read data, or %NULL.terminator_pos is location to store position of line terminator, or %NULL.the status of the operation..read_line_string (object buffer, int terminator_pos)
Reads a line from a #GIOChannel, using a #GString as a buffer.
buffer is a #GString into which the line will be written. If @buffer already contains data, the old data will be overwritten..terminator_pos is location to store position of line terminator, or %NULL.the status of the operation..read_to_end ()
Reads all the remaining data from the file.
str_return is Location to store a pointer to a string holding the remaining data in the #GIOChannel. This data should be freed with g_free() when no longer needed. This data is terminated by an extra nul character, but there may be other nuls in the intervening data..length is location to store length of the data.%G_IO_STATUS_NORMAL on success. This function never returns %G_IO_STATUS_EOF..read_unichar ()
Reads a Unicode character from @channel. This function cannot be called on a channel with %NULL encoding.
thechar is a location to return a character.a #GIOStatus.ref ()
Increments the reference count of a #GIOChannel.
the @channel that was passed in (since 2.6).seek (int offset, string type)
Sets the current position in the #GIOChannel, similar to the standard library function fseek().
offset is an offset, in bytes, which is added to the position specified by @type.type is the position in the file, which can be %G_SEEK_CUR (the current position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the file).%G_IO_ERROR_NONE if the operation was successful..seek_position (int offset, string type)
Replacement for g_io_channel_seek() with the new API.
offset is The offset in bytes from the position specified by @type.type is a #GSeekType. The type %G_SEEK_CUR is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details..the status of the operation..set_buffer_size (int size)
Sets the buffer size.
size is the size of the buffer, or 0 to let GLib pick a good size.None.set_buffered (bool buffered)
The buffering state can only be set if the channel's encoding is %NULL. For any other encoding, the channel must be buffered. A buffered channel can only be set unbuffered if the channel's internal buffers have been flushed. Newly created channels or channels which have returned %G_IO_STATUS_EOF not require such a flush. For write-only channels, a call to g_io_channel_flush () is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position (). This includes the possibility of seeking with seek type %G_SEEK_CUR and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them. On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code. The default state of the channel is buffered.
buffered is whether to set the channel buffered or unbuffered.None.set_close_on_unref (bool do_close)
Whether to close the channel on the final unref of the #GIOChannel data structure. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. Setting this flag to %TRUE for a channel you have already closed can cause problems when the final reference to the #GIOChannel is dropped.
do_close is Whether to close the channel on the final unref of the GIOChannel data structure..None.set_encoding (string encoding)
Sets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8. The encoding %NULL is safe to use with binary data. The encoding can only be set if one of the following conditions is true: - The channel was just created, and has not been written to or read from yet. - The channel is write-only. - The channel is a file, and the file pointer was just repositioned by a call to g_io_channel_seek_position(). (This flushes all the internal buffers.) - The current encoding is %NULL or UTF-8. - One of the (new API) read functions has just returned %G_IO_STATUS_EOF (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL). - One of the functions g_io_channel_read_chars() or g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or %G_IO_STATUS_ERROR. This may be useful in the case of %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Returning one of these statuses from g_io_channel_read_line(), g_io_channel_read_line_string(), or g_io_channel_read_to_end() does not guarantee that the encoding can be changed. Channels which do not meet one of the above conditions cannot call g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if they are "seekable", cannot call g_io_channel_write_chars() after calling one of the API "read" functions.
encoding is the encoding type.%G_IO_STATUS_NORMAL if the encoding was successfully set.set_flags (string flags)
Sets the (writeable) flags in @channel to (@flags & %G_IO_FLAG_SET_MASK).
flags is the flags to set on the IO channel.the status of the operation..set_line_term (string line_term, int length)
This sets the string that #GIOChannel uses to determine where in the file a line break occurs.
line_term is The line termination string. Use %NULL for autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels..length is The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls..None.shutdown (bool flush)
Close an IO channel. Any pending data to be written will be flushed if
is %TRUE. The channel will not be freed until the last reference is dropped using g_io_channel_unref().flush is if %TRUE, flush pending.the status of the operation..unix_get_fd ()
Returns the file descriptor of the #GIOChannel. On Windows this function returns the file descriptor or socket of the #GIOChannel.
the file descriptor of the #GIOChannel..unref ()
Decrements the reference count of a #GIOChannel.
None.write (string buf, int count, int bytes_written)
Writes data to a #GIOChannel.
buf is the buffer containing the data to write.count is the number of bytes to write.bytes_written is the number of bytes actually written.%G_IO_ERROR_NONE if the operation was successful..write_chars (list buf, int count)
Replacement for g_io_channel_write() with the new API. On seekable channels with encodings other than %NULL or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars () may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding ().
buf is a buffer to write data from.count is the size of the buffer. If -1, the buffer is taken to be a nul-terminated string..bytes_written is The number of bytes written. This can be nonzero even if the return value is not %G_IO_STATUS_NORMAL. If the return value is %G_IO_STATUS_NORMAL and the channel is blocking, this will always be equal to @count if @count >= 0..the status of the operation..write_unichar (int thechar)
Writes a Unicode character to @channel. This function cannot be called on a channel with %NULL encoding.
thechar is a character.a #GIOStatus.
