![]() |
![]() |
Inheritance diagram for Glib::IOChannel:
Public Member Functions | |
virtual | ~IOChannel () |
IOStatus | read (gunichar& unichar, std::auto_ptr<Glib::Error>& error) |
This function cannot be called on a channel with 0 encoding. | |
IOStatus | read (char* buf, gsize count, gsize& bytes_read, std::auto_ptr<Glib::Error>& error) |
Replacement for g_io_channel_read() with the new API. | |
IOStatus | read (Glib::ustring& str, gsize count, std::auto_ptr<Glib::Error>& error) |
Read a maximum of count bytes into str. | |
IOStatus | read_line (Glib::ustring& line, std::auto_ptr<Glib::Error>& error) |
Read a whole line. | |
IOStatus | read_to_end (Glib::ustring& str, std::auto_ptr<Glib::Error>& error) |
Reads all the remaining data from the file. | |
IOStatus | write (const Glib::ustring& str, std::auto_ptr<Glib::Error>& error) |
Write a string to the I/O channel. | |
IOStatus | write (const char* buf, gssize count, gsize& bytes_written, std::auto_ptr<Glib::Error>& error) |
Replacement for g_io_channel_write() with the new API. | |
IOStatus | write (gunichar unichar, std::auto_ptr<Glib::Error>& error) |
This function cannot be called on a channel with 0 encoding. | |
IOStatus | seek (gint64 offset, SeekType type, std::auto_ptr<Glib::Error>& error) |
Replacement for g_io_channel_seek() with the new API. | |
IOStatus | flush (std::auto_ptr<Glib::Error>& error) |
Flushes the write buffer for the GIOChannel. | |
IOStatus | close (bool flush, std::auto_ptr<Glib::Error>& error) |
Close an IO channel. | |
gsize | get_buffer_size () const |
Gets the buffer size. | |
void | set_buffer_size (gsize size) |
Sets the buffer size. | |
IOFlags | get_flags () const |
Gets the current flags for a G::IOChannel, including read-only flags such as G::IO_FLAG_IS_READABLE. | |
IOStatus | set_flags (IOFlags flags, std::auto_ptr<Glib::Error>& error) |
Sets the (writeable) flags in channel to ( flags & G::IO_CHANNEL_SET_MASK). | |
void | set_buffered (bool buffered) |
The buffering state can only be set if the channel's encoding is 0 . | |
bool | get_buffered () const |
Returns whether channel is buffered. | |
IOCondition | get_buffer_condition () const |
This function returns a G::IOCondition depending on whether there is data to be read/space to write data in the internal buffers in the G::IOChannel. | |
bool | get_close_on_unref () const |
Returns whether the file/socket/whatever associated with channel will be closed when channel receives its final unref and is destroyed. | |
void | set_close_on_unref (bool do_close) |
Setting this flag to true for a channel you have already closed can cause problems. | |
IOStatus | set_encoding (const std::string& encoding, std::auto_ptr<Glib::Error>& error) |
Sets the encoding for the input/output of the channel. | |
std::string | get_encoding () const |
Get the encoding of the I/O channel. | |
void | set_line_term (const std::string& term=std::string()) |
std::string | get_line_term () const |
Glib::RefPtr<IOSource> | create_watch (IOCondition condition) |
Creates an IOSource object. | |
virtual void | reference () const |
virtual void | unreference () const |
GIOChannel* | gobj () |
const GIOChannel* | gobj () const |
Static Public Member Functions | |
static Glib::RefPtr<IOChannel> | create_from_file (const std::string& filename, const std::string& mode, std::auto_ptr<Glib::Error>& error) |
Open a file filename as an I/O channel using mode mode. | |
static Glib::RefPtr<IOChannel> | create_from_fd (int fd) |
Creates an I/O channel from a file descriptor. | |
static Glib::RefPtr<IOChannel> | create_from_win32_fd (int fd) |
Create an I/O channel for C runtime (emulated Unix-like) file descriptors. | |
static Glib::RefPtr<IOChannel> | create_from_win32_socket (int socket) |
Create an I/O channel for a winsock socket. | |
Protected Member Functions | |
IOChannel () | |
Constructor that should be used by derived classes. | |
virtual IOStatus | read_vfunc (char* buf, gsize count, gsize& bytes_read) |
virtual IOStatus | write_vfunc (const char* buf, gsize count, gsize& bytes_written) |
virtual IOStatus | seek_vfunc (gint64 offset, SeekType type) |
virtual IOStatus | close_vfunc () |
virtual IOStatus | set_flags_vfunc (IOFlags flags) |
virtual IOFlags | get_flags_vfunc () |
virtual Glib::RefPtr<Glib::Source> | create_watch_vfunc (IOCondition cond) |
Protected Attributes | |
GIOChannel* | gobject_ |
Note that IOChannels implement an automatic implicit character set conversion to the data stream, and usually will not pass by default binary data unchanged. To set the encoding of the channel, use e.g. set_encoding("ISO-8859-15"). To set the channel to no encoding, use set_encoding() without any arguments.
You can create an IOChannel with one of the static create methods, or implement one yourself, in which case you have to 1) override all _vfunc() members. 2) set the GIOChannel flags in your constructor.
|
|
|
Constructor that should be used by derived classes. Use this constructor if you want to inherit from IOChannel. It will set up a GIOChannel that will call the vfuncs of your class even if it is being used from C code, and it will keep a reference to the C++ code while the GIOChannel exists. |
|
Close an IO channel.
Any pending data to be written will be flushed if flush is
|
|
Reimplemented in Glib::StreamIOChannel. |
|
Creates an I/O channel from a file descriptor. On Unix, IOChannels created with this function work for any file descriptor or socket.
On Win32, this can be used either for files opened with the MSVCRT (the Microsoft run-time C library)
The term file descriptor as used in the context of Win32 refers to the emulated Unix-like file descriptors MSVCRT provides. The native corresponding concept is file |
|
Open a file filename as an I/O channel using mode mode. This channel will be closed when the last reference to it is dropped, so there is no need to call close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed).
|
|
Create an I/O channel for C runtime (emulated Unix-like) file descriptors.
After calling add_watch() on a I/O channel returned by this function, you shouldn't call read() on the file descriptor. This is because adding polling for a file descriptor is implemented on Win32 by starting a thread that sits blocked in a |
|
Create an I/O channel for a winsock socket.
The parameter should be a |
|
Creates an IOSource object. Create a slot from a function to be called when condition is met for the channel with sigc::ptr_fun() or sigc::mem_fun() and pass it into the connect() function of the returned IOSource object. Polling of the channel will start when you attach a MainContext object to the returned IOSource object using its attach() function. Glib::signal_io().connect() is a simpler interface to the same functionality, for the case where you want to add the source to the default main context.
|
|
Reimplemented in Glib::StreamIOChannel. |
|
Flushes the write buffer for the GIOChannel.
|
|
This function returns a G::IOCondition depending on whether there is data to be read/space to write data in the internal buffers in the G::IOChannel. Only the flags G::IO_IN and G::IO_OUT may be set.
|
|
Gets the buffer size.
|
|
Returns whether channel is buffered.
|
|
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
|
|
Get the encoding of the I/O channel.
|
|
Gets the current flags for a G::IOChannel, 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_WRITEABLE 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.
|
|
Reimplemented in Glib::StreamIOChannel. |
|
|
|
|
|
|
|
Read a maximum of count bytes into str.
|
|
Replacement for g_io_channel_read() with the new API.
|
|
This function cannot be called on a channel with
|
|
Read a whole line. Reads until the line separator is found, which is included in the result string.
|
|
Reads all the remaining data from the file.
|
|
Reimplemented in Glib::StreamIOChannel. |
|
|
|
Replacement for g_io_channel_seek() with the new API.
|
|
Reimplemented in Glib::StreamIOChannel. |
|
Sets the buffer size.
|
|
The buffering state can only be set if the channel's encoding is 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.
|
|
Setting this flag to
|
|
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 The encoding can only be set if one of the following conditions is true:
Channels which do not meet one of the above conditions cannot call seek_position() with a seek type of Glib::SEEK_TYPE_CUR and, if they are "seekable", cannot call write() after calling one of the API "read" methods.
|
|
Sets the (writeable) flags in channel to ( flags & G::IO_CHANNEL_SET_MASK).
|
|
Reimplemented in Glib::StreamIOChannel. |
|
|
|
|
|
This function cannot be called on a channel with
|
|
Replacement for g_io_channel_write() with the new API.
On seekable channels with encodings other than
|
|
Write a string to the I/O channel. Note that this method does not return the number of characters written. If the channel is blocking and the returned value is Glib::IO_STATUS_NORMAL, the whole string was written.
|
|
Reimplemented in Glib::StreamIOChannel. |
|
|