696 lines
26 KiB
C++
696 lines
26 KiB
C++
// -*- c++ -*-
|
|
// Generated by gtkmmproc -- DO NOT MODIFY!
|
|
#ifndef _GLIBMM_IOCHANNEL_H
|
|
#define _GLIBMM_IOCHANNEL_H
|
|
|
|
|
|
// -*- c++ -*-
|
|
/* $Id$ */
|
|
|
|
/* Copyright (C) 2002 The gtkmm Development Team
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the Free
|
|
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
|
|
#include <glibmm/error.h>
|
|
#include <glibmm/main.h>
|
|
#include <glibmm/refptr.h>
|
|
#include <glibmm/ustring.h>
|
|
#include <glib/gtypes.h>
|
|
|
|
#include <string>
|
|
#include <glibmmconfig.h>
|
|
|
|
GLIBMM_USING_STD(string)
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
extern "C" { typedef struct _GIOChannel GIOChannel; }
|
|
#endif
|
|
|
|
|
|
namespace Glib
|
|
{
|
|
|
|
class Source;
|
|
class IOSource;
|
|
|
|
/** @addtogroup glibmmEnums Enums and Flags */
|
|
|
|
/**
|
|
* @ingroup glibmmEnums
|
|
*/
|
|
enum SeekType
|
|
{
|
|
SEEK_TYPE_CUR,
|
|
SEEK_TYPE_SET,
|
|
SEEK_TYPE_END
|
|
};
|
|
|
|
|
|
/**
|
|
* @ingroup glibmmEnums
|
|
*/
|
|
enum IOStatus
|
|
{
|
|
IO_STATUS_ERROR,
|
|
IO_STATUS_NORMAL,
|
|
IO_STATUS_EOF,
|
|
IO_STATUS_AGAIN
|
|
};
|
|
|
|
|
|
/**
|
|
* @ingroup glibmmEnums
|
|
* @par Bitwise operators:
|
|
* <tt>%IOFlags operator|(IOFlags, IOFlags)</tt><br>
|
|
* <tt>%IOFlags operator&(IOFlags, IOFlags)</tt><br>
|
|
* <tt>%IOFlags operator^(IOFlags, IOFlags)</tt><br>
|
|
* <tt>%IOFlags operator~(IOFlags)</tt><br>
|
|
* <tt>%IOFlags& operator|=(IOFlags&, IOFlags)</tt><br>
|
|
* <tt>%IOFlags& operator&=(IOFlags&, IOFlags)</tt><br>
|
|
* <tt>%IOFlags& operator^=(IOFlags&, IOFlags)</tt><br>
|
|
*/
|
|
enum IOFlags
|
|
{
|
|
IO_FLAG_APPEND = 1 << 0,
|
|
IO_FLAG_NONBLOCK = 1 << 1,
|
|
IO_FLAG_IS_READABLE = 1 << 2,
|
|
IO_FLAG_IS_WRITEABLE = 1 << 3,
|
|
IO_FLAG_IS_SEEKABLE = 1 << 4,
|
|
IO_FLAG_GET_MASK = 0x0,
|
|
IO_FLAG_SET_MASK = 0x1
|
|
};
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags operator|(IOFlags lhs, IOFlags rhs)
|
|
{ return static_cast<IOFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags operator&(IOFlags lhs, IOFlags rhs)
|
|
{ return static_cast<IOFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags operator^(IOFlags lhs, IOFlags rhs)
|
|
{ return static_cast<IOFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags operator~(IOFlags flags)
|
|
{ return static_cast<IOFlags>(~static_cast<unsigned>(flags)); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags& operator|=(IOFlags& lhs, IOFlags rhs)
|
|
{ return (lhs = static_cast<IOFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags& operator&=(IOFlags& lhs, IOFlags rhs)
|
|
{ return (lhs = static_cast<IOFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
|
|
|
|
/** @ingroup glibmmEnums */
|
|
inline IOFlags& operator^=(IOFlags& lhs, IOFlags rhs)
|
|
{ return (lhs = static_cast<IOFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
|
|
|
|
|
|
/** Exception class for IOChannel errors.
|
|
*/
|
|
class IOChannelError : public Glib::Error
|
|
{
|
|
public:
|
|
enum Code
|
|
{
|
|
FILE_TOO_BIG,
|
|
INVALID_ARGUMENT,
|
|
IO_ERROR,
|
|
IS_DIRECTORY,
|
|
NO_SPACE_LEFT,
|
|
NO_SUCH_DEVICE,
|
|
OVERFLOWN,
|
|
BROKEN_PIPE,
|
|
FAILED
|
|
};
|
|
|
|
IOChannelError(Code error_code, const Glib::ustring& error_message);
|
|
explicit IOChannelError(GError* gobject);
|
|
Code code() const;
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
private:
|
|
static void throw_func(GError* gobject);
|
|
friend void wrap_init(); // uses throw_func()
|
|
#endif
|
|
};
|
|
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
class GlibmmIOChannel;
|
|
#endif
|
|
|
|
/** IOChannel aims to provide portable I/O support for files, pipes
|
|
* and sockets, and to integrate them with the GLib main event loop.
|
|
*
|
|
* 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.
|
|
*
|
|
* @note This feature of being able to implement a custom Glib::IOChannel is
|
|
* deprecated in glibmm 2.2. The vfunc interface has not yet stabilized
|
|
* enough to allow that -- the C++ wrapper went in by pure accident. Besides,
|
|
* it isn't terribly useful either. Thus please refrain from overriding any
|
|
* IOChannel vfuncs.
|
|
*/
|
|
class IOChannel : public sigc::trackable
|
|
{
|
|
public:
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
typedef IOChannel CppObjectType;
|
|
typedef GIOChannel BaseObjectType;
|
|
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
|
|
|
|
private:
|
|
|
|
|
|
public:
|
|
virtual ~IOChannel();
|
|
|
|
/** Open a file @a filename as an I/O channel using mode @a 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).
|
|
* @param filename The name of the file to open.
|
|
* @param mode One of <tt>"r"</tt>, <tt>"w"</tt>, <tt>"a"</tt>,
|
|
* <tt>"r+"</tt>, <tt>"w+"</tt>, <tt>"a+"</tt>. These have the
|
|
* same meaning as in <tt>fopen()</tt>.
|
|
* @return An IOChannel for the opened file.
|
|
* @throw Glib::FileError
|
|
*/
|
|
static Glib::RefPtr<IOChannel> create_from_file(const std::string& filename, const std::string& mode);
|
|
|
|
|
|
/** 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) <tt>_open()</tt> or <tt>_pipe()</tt>,
|
|
* including file descriptors 0, 1 and 2 (corresponding to <tt>stdin</tt>,
|
|
* <tt>stdout</tt> and <tt>stderr</tt>), or for Winsock <tt>SOCKET</tt>s. If
|
|
* the parameter is a legal file descriptor, it is assumed to be such,
|
|
* otherwise it should be a <tt>SOCKET</tt>. This relies on <tt>SOCKET</tt>s
|
|
* and file descriptors not overlapping. If you want to be certain, call
|
|
* either create_from_win32_fd() or create_from_win32_socket() instead as
|
|
* appropriate.
|
|
*
|
|
* 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 <tt>HANDLE</tt>. There isn't as of yet
|
|
* a way to get IOChannels for Win32 file <tt>HANDLE</tt>s.
|
|
*/
|
|
static Glib::RefPtr<IOChannel> create_from_fd(int fd);
|
|
|
|
|
|
/* defined(DOXYGEN_SHOULD_SKIP_THIS) actually does the opposite of what it looks like... */
|
|
#if defined(G_OS_WIN32) || defined(DOXYGEN_SHOULD_SKIP_THIS)
|
|
|
|
/** 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 <tt>%read()</tt> from the file descriptor most of
|
|
* the time. All reads from the file descriptor should be done by this
|
|
* internal GLib thread. Your code should call only IOChannel::read().
|
|
*/
|
|
static Glib::RefPtr<IOChannel> create_from_win32_fd(int fd);
|
|
|
|
|
|
/** Create an I/O channel for a winsock socket. The parameter should be a
|
|
* <tt>SOCKET</tt>. Contrary to I/O channels for file descriptors (on Win32),
|
|
* you can use normal <tt>recv()</tt> or <tt>recvfrom()</tt> on sockets even
|
|
* if GLib is polling them.
|
|
*/
|
|
static Glib::RefPtr<IOChannel> create_from_win32_socket(int socket);
|
|
|
|
|
|
#endif /* defined(G_OS_WIN32) || defined(DOXYGEN_SHOULD_SKIP_THIS) */
|
|
|
|
/** Read a single UCS-4 character.
|
|
* @retval unichar The Unicode character.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** This function cannot be called on a channel with <tt>0</tt> encoding.
|
|
* @param thechar A location to return a character.
|
|
* @param error A location to return an error of type G::ConvertError
|
|
* or G::IOChannelError.
|
|
* @return A G::IOStatus.
|
|
*/
|
|
IOStatus read(gunichar& unichar);
|
|
|
|
/** Read a character sequence into memory.
|
|
* @param buf A buffer to read data into.
|
|
* @param count The size of the buffer in bytes. Note that the buffer may
|
|
* not be complelely filled even if there is data in the buffer if the
|
|
* remaining data is not a complete character.
|
|
* @retval bytes_read The number of bytes read. This may be zero even on
|
|
* success if @a count < 6 and the channel's encoding is not <tt>""</tt>.
|
|
* This indicates that the next UTF-8 character is too wide for the buffer.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** Replacement for g_io_channel_read() with the new API.
|
|
* @param buf A buffer to read data into.
|
|
* @param count The size of the buffer. Note that the buffer may
|
|
* not be complelely filled even if there is data
|
|
* in the buffer if the remaining data is not a
|
|
* complete character.
|
|
* @param bytes_read The number of bytes read. This may be zero even on
|
|
* success if count < 6 and the channel's encoding is non-<tt>0</tt>.
|
|
* This indicates that the next UTF-8 character is too wide for
|
|
* the buffer.
|
|
* @param error A location to return an error of type G::ConvertError
|
|
* or G::IOChannelError.
|
|
* @return The status of the operation.
|
|
*/
|
|
IOStatus read(char* buf, gsize count, gsize& bytes_read);
|
|
|
|
/** Read a maximum of @a count bytes into @a str.
|
|
* @param count The maximum number of bytes to read.
|
|
* @retval str The characters that have been read.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
IOStatus read(Glib::ustring& str, gsize count);
|
|
|
|
/** Read a whole line.
|
|
* Reads until the line separator is found, which is included
|
|
* in the result string.
|
|
* @retval line The line that was read.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
IOStatus read_line(Glib::ustring& line);
|
|
|
|
|
|
/** Reads all the remaining data from the file.
|
|
* @retval str The resulting string.
|
|
* @return Glib::IO_STATUS_NORMAL on success. This function never
|
|
* returns Glib::IO_STATUS_EOF.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
IOStatus read_to_end(Glib::ustring& str);
|
|
|
|
|
|
/** 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.
|
|
* @param str the string to write.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
IOStatus write(const Glib::ustring& str);
|
|
|
|
/** Write a memory area of @a count bytes to the I/O channel.
|
|
* @param buf The start of the memory area.
|
|
* @param count The number of bytes to write.
|
|
* @retval bytes_written The number of bytes written to the channel.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** Replacement for g_io_channel_write() with the new API.
|
|
*
|
|
* On seekable channels with encodings other than <tt>0</tt> 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().
|
|
* @param buf A buffer to write data from.
|
|
* @param count The size of the buffer. If -1, the buffer
|
|
* is taken to be a nul-terminated string.
|
|
* @param bytes_written 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 @a count if @a count >= 0.
|
|
* @param error A location to return an error of type G::ConvertError
|
|
* or G::IOChannelError.
|
|
* @return The status of the operation.
|
|
*/
|
|
IOStatus write(const char* buf, gssize count, gsize& bytes_written);
|
|
|
|
/** Write a single UCS-4 character to the I/O channel.
|
|
* @param unichar The character to write.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** This function cannot be called on a channel with <tt>0</tt> encoding.
|
|
* @param thechar A character.
|
|
* @param error A location to return an error of type G::ConvertError
|
|
* or G::IOChannelError.
|
|
* @return A G::IOStatus.
|
|
*/
|
|
IOStatus write(gunichar unichar);
|
|
|
|
/** Seek the I/O channel to a specific position.
|
|
* @param offset The offset in bytes from the position specified by @a type.
|
|
* @param type A SeekType. The type Glib::SEEK_TYPE_CUR is only allowed in
|
|
* those cases where a call to set_encoding() is allowed. See the
|
|
* documentation for set_encoding() for details.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** Replacement for g_io_channel_seek() with the new API.
|
|
* @param offset The offset in bytes from the position specified by @a type .
|
|
* @param type A G::SeekType. 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.
|
|
* @param error A location to return an error of type G::IOChannelError.
|
|
* @return The status of the operation.
|
|
*/
|
|
IOStatus seek(gint64 offset, SeekType type = SEEK_TYPE_SET);
|
|
|
|
/** Flush the buffers of the I/O channel.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
* @throw Glib::ConvertError
|
|
*/
|
|
|
|
/** Flushes the write buffer for the GIOChannel.
|
|
* @param error Location to store an error of type G::IOChannelError.
|
|
* @return The status of the operation: One of
|
|
* G::IO_CHANNEL_NORMAL, G::IO_CHANNEL_AGAIN, or
|
|
* G::IO_CHANNEL_ERROR.
|
|
*/
|
|
IOStatus flush();
|
|
|
|
/** Close the I/O channel.
|
|
* Any pending data to be written will be flushed if @a flush is <tt>true</tt>.
|
|
* The channel will not be freed until the last reference is dropped.
|
|
* Accessing the channel after closing it is considered an error.
|
|
* @param flush Whether to flush() pending data before closing the channel.
|
|
* @return The status of the operation.
|
|
* @throw Glib::IOChannelError
|
|
*/
|
|
|
|
/** Close an IO channel. Any pending data to be written will be
|
|
* flushed if @a flush is <tt>true</tt>. The channel will not be freed until the
|
|
* last reference is dropped using g_io_channel_unref().
|
|
* @param flush If <tt>true</tt>, flush pending.
|
|
* @param err Location to store a G::IOChannelError.
|
|
* @return The status of the operation.
|
|
*/
|
|
IOStatus close(bool flush = true);
|
|
|
|
/** Get the IOChannel internal buffer size.
|
|
* @return The buffer size.
|
|
*/
|
|
|
|
/** Gets the buffer size.
|
|
* @return The size of the buffer.
|
|
*/
|
|
gsize get_buffer_size() const;
|
|
|
|
/** Set the internal IOChannel buffer size.
|
|
* @param size The buffer size the IOChannel should use.
|
|
*/
|
|
|
|
/** Sets the buffer size.
|
|
* @param size The size of the buffer. 0 == pick a good size.
|
|
*/
|
|
void set_buffer_size(gsize size);
|
|
|
|
/** Get the current flags for a IOChannel, including read-only
|
|
* flags such as Glib::IO_FLAG_IS_READABLE.
|
|
*
|
|
* The values of the flags Glib::IO_FLAG_IS_READABLE and
|
|
* Glib::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 <tt>shutdown()</tt> function), the user
|
|
* should immediately call get_flags() to update the internal values of these
|
|
* flags.
|
|
* @return Bitwise combination of the flags set on the 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.
|
|
* @return The flags which are set on the channel.
|
|
*/
|
|
IOFlags get_flags() const;
|
|
|
|
/** Set flags on the IOChannel.
|
|
* @param flags Bitwise combination of the flags to set.
|
|
* @return The operation result code.
|
|
* @throw Glib::IOChannelError
|
|
*/
|
|
|
|
/** Sets the (writeable) flags in @a channel to ( @a flags & G::IO_CHANNEL_SET_MASK).
|
|
* @param flags The flags to set on the IO channel.
|
|
* @param error A location to return an error of type G::IOChannelError.
|
|
* @return The status of the operation.
|
|
*/
|
|
IOStatus set_flags(IOFlags flags);
|
|
|
|
/** Set the buffering status of the I/O channel.
|
|
* The buffering state can only be set if the channel's encoding is
|
|
* <tt>""</tt>. 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 Glib::IO_STATUS_EOF not require such a flush. For write-only
|
|
* channels, a call to flush() is sufficient. For all other channels, the
|
|
* buffers may be flushed by a call to seek(). This includes the possibility
|
|
* of seeking with seek type Glib::SEEK_TYPE_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.
|
|
*
|
|
* The default state of the channel is buffered.
|
|
*
|
|
* @param buffered Whether to set the channel buffered or unbuffered.
|
|
*/
|
|
|
|
/** The buffering state can only be set if the channel's encoding
|
|
* is <tt>0</tt>. 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.
|
|
* @param buffered Whether to set the channel buffered or unbuffered.
|
|
*/
|
|
void set_buffered(bool buffered);
|
|
|
|
/** Get the buffering status of the I/O channel.
|
|
* @return The buffering status of the channel.
|
|
*/
|
|
|
|
/** Returns whether @a channel is buffered.
|
|
* @return <tt>true</tt> if the @a channel is buffered.
|
|
*/
|
|
bool get_buffered() const;
|
|
|
|
/** Returns an IOCondition depending on whether there is data to be
|
|
* read/space to write data in the internal buffers in the I/O channel.
|
|
* Only the flags Glib::IO_IN and Glib::IO_OUT may be set.
|
|
* @return Bitwise combination of Glib::IOCondition flags.
|
|
*/
|
|
|
|
/** 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.
|
|
* @return A G::IOCondition.
|
|
*/
|
|
IOCondition get_buffer_condition() const;
|
|
|
|
/** Returns whether the file/socket/whatever associated with the I/O channel
|
|
* will be closed when the channel receives its final unref and is destroyed.
|
|
* The default value of this is <tt>true</tt> for channels created by
|
|
* create_from_file(), and <tt>false</tt> for all other channels.
|
|
* @return Whether the channel will be closed on the final unref of the
|
|
* IOChannel object.
|
|
*/
|
|
|
|
/** Returns whether the file/socket/whatever associated with @a channel
|
|
* will be closed when @a channel receives its final unref and is
|
|
* destroyed. The default value of this is <tt>true</tt> for channels created
|
|
* by g_io_channel_new_file(), and <tt>false</tt> for all other channels.
|
|
* @return Whether the channel will be closed on the final unref of
|
|
* the GIOChannel data structure.
|
|
*/
|
|
bool get_close_on_unref() const;
|
|
|
|
/** Setting this flag to <tt>true</tt> for a channel you have already closed
|
|
* can cause problems.
|
|
* @param do_close Whether to close the channel on the final unref of the
|
|
* IOChannel object. The default value of this is <tt>true</tt> for channels
|
|
* created by create_from_file(), and <tt>false</tt> for all other channels.
|
|
*/
|
|
|
|
/** Setting this flag to <tt>true</tt> for a channel you have already closed
|
|
* can cause problems.
|
|
* @param do_close Whether to close the channel on the final unref of
|
|
* the GIOChannel data structure. The default value of
|
|
* this is <tt>true</tt> for channels created by g_io_channel_new_file(),
|
|
* and <tt>false</tt> for all other channels.
|
|
*/
|
|
void set_close_on_unref(bool do_close);
|
|
|
|
/** 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 <tt>""</tt> 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 seek_position(). (This flushes all the internal buffers.)
|
|
* -# The current encoding is <tt>""</tt> or UTF-8.
|
|
* -# One of the read methods has just returned Glib::IO_STATUS_EOF (or, in
|
|
* the case of read_to_end(), Glib::IO_STATUS_NORMAL).
|
|
* -# The read() method has returned Glib::IO_STATUS_AGAIN or thrown
|
|
* a Glib::Error exception. This may be useful in the case of
|
|
* ConvertError::ILLEGAL_SEQUENCE. Returning one of these statuses
|
|
* from read_line() or read_to_end() does <em>not</em> guarantee that
|
|
* the encoding can be changed.
|
|
*
|
|
* 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.
|
|
*
|
|
* @param encoding The encoding name, or <tt>""</tt> for binary.
|
|
* @return Glib::IO_STATUS_NORMAL if the encoding was successfully set.
|
|
* @throw Glib::IOChannelError
|
|
*/
|
|
IOStatus set_encoding(const std::string& encoding = std::string());
|
|
|
|
|
|
/** Get the encoding of the I/O channel.
|
|
* @return The current encoding of the channel.
|
|
*/
|
|
std::string get_encoding() const;
|
|
|
|
|
|
void set_line_term(const std::string& term = std::string());
|
|
|
|
|
|
std::string get_line_term() const;
|
|
|
|
|
|
/** 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.
|
|
* @param condition The condition to watch for.
|
|
* @return An IOSource object that can be polled from a MainContext's event loop.
|
|
*/
|
|
Glib::RefPtr<IOSource> create_watch(IOCondition condition);
|
|
|
|
|
|
virtual void reference() const;
|
|
virtual void unreference() const;
|
|
|
|
|
|
GIOChannel* gobj() { return gobject_; }
|
|
const GIOChannel* gobj() const { return gobject_; }
|
|
|
|
protected:
|
|
GIOChannel* gobject_;
|
|
|
|
/** 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.
|
|
*/
|
|
IOChannel();
|
|
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
IOChannel(GIOChannel* gobject, bool take_copy);
|
|
#endif
|
|
|
|
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);
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
friend class Glib::GlibmmIOChannel;
|
|
#endif
|
|
|
|
|
|
};
|
|
|
|
Glib::RefPtr<IOChannel> wrap(GIOChannel* gobject, bool take_copy = false);
|
|
|
|
} // namespace Glib
|
|
|
|
|
|
#endif /* _GLIBMM_IOCHANNEL_H */
|
|
|