qiodevice man page on Peanut

Man page or keyword search:  
man Server   7435 pages
apropos Keyword Search (all sections)
Output format
Peanut logo
[printable version]

QIODevice(3qt)							QIODevice(3qt)

NAME
       QIODevice - The base class of I/O devices

SYNOPSIS
       All the functions in this class are reentrant when Qt is built with
       thread support.</p>

       #include <qiodevice.h>

       Inherited by QBuffer, QFile, QSocket, and QSocketDevice.

   Public Members
       typedef Q_ULONG Offset
       QIODevice ()
       virtual ~QIODevice ()
       int flags () const
       int mode () const
       int state () const
       bool isDirectAccess () const
       bool isSequentialAccess () const
       bool isCombinedAccess () const
       bool isBuffered () const
       bool isRaw () const
       bool isSynchronous () const
       bool isAsynchronous () const
       bool isTranslated () const
       bool isReadable () const
       bool isWritable () const
       bool isReadWrite () const
       bool isInactive () const
       bool isOpen () const
       int status () const
       void resetStatus ()
       virtual bool open ( int mode ) = 0
       virtual void close () = 0
       virtual void flush () = 0
       virtual Offset size () const = 0
       virtual Offset at () const
       virtual bool at ( Offset pos )
       virtual bool atEnd () const
       bool reset ()
       virtual Q_LONG readBlock ( char * data, Q_ULONG maxlen ) = 0
       virtual Q_LONG writeBlock ( const char * data, Q_ULONG len ) = 0
       virtual Q_LONG readLine ( char * data, Q_ULONG maxlen )
       Q_LONG writeBlock ( const QByteArray & data )
       virtual QByteArray readAll ()
       virtual int getch () = 0
       virtual int putch ( int ch ) = 0
       virtual int ungetch ( int ch ) = 0

   Protected Members
       void setFlags ( int flags )
       void setType ( int type )
       void setMode ( int mode )
       void setState ( int state )
       void setStatus ( int s )

DESCRIPTION
       The QIODevice class is the base class of I/O devices.

       An I/O device represents a medium that one can read bytes from and/or
       write bytes to. The QIODevice class is the abstract superclass of all
       such devices; classes such as QFile, QBuffer and QSocket inherit
       QIODevice and implement virtual functions such as write()
       appropriately.

       Although applications sometimes use QIODevice directly, it is usually
       better to use QTextStream and QDataStream, which provide stream
       operations on any QIODevice subclass. QTextStream provides text-
       oriented stream functionality (for human-readable ASCII files, for
       example), whereas QDataStream deals with binary data in a totally
       platform-independent manner.

       The public member functions in QIODevice roughly fall into two groups:
       the action functions and the state access functions. The most important
       action functions are:

       open() opens a device for reading and/or writing, depending on the mode
       argument.

       close() closes the device and tidies up (e.g. flushes buffered data)

       readBlock() reads a block of data from the device.

       writeBlock() writes a block of data to the device.

       readLine() reads a line (of text, usually) from the device.

       flush() ensures that all buffered data are written to the real device.

       There are also some other, less used, action functions:

       getch() reads a single character.

       ungetch() forgets the last call to getch(), if possible.

       putch() writes a single character.

       size() returns the size of the device, if there is one.

       at() returns the current read/write pointer's position, if there is one
       for this device, or it moves the pointer if given an offset.

       atEnd() indicates whether there is more to read, if this is meaningful
       for this device.

       reset() moves the read/write pointer to the start of the device, if
       that is possible for this device.

       The state access are all "get" functions. The QIODevice subclass calls
       setState() to update the state, and simple access functions tell the
       user of the device what the device's state is. Here are the settings,
       and their associated access functions:

       Access type. Some devices are direct access (it is possible to
       read/write anywhere), whereas others are sequential. QIODevice provides
       the access functions (isDirectAccess(), isSequentialAccess(), and
       isCombinedAccess()) to tell users what a given I/O device supports.

       Buffering. Some devices are accessed in raw mode, whereas others are
       buffered. Buffering usually provides greater efficiency, particularly
       for small read/write operations. isBuffered() tells the user whether a
       given device is buffered. (This can often be set by the application in
       the call to open().)

       Synchronicity. Synchronous devices work immediately (for example,
       files). When you read from a file, the file delivers its data straight
       away. Other kinds of device, such as a socket connected to a HTTP
       server, may not deliver the data until seconds after you ask to read
       it. isSynchronous() and isAsynchronous() tell the user how this device
       operates.

       CR/LF translation. For simplicity, applications often like to see just
       a single CR/LF style, and QIODevice subclasses can provide this.
       isTranslated() returns TRUE if this object translates CR/LF to just LF.
       (This can often be set by the application in the call to open().)

       Permissions. Some files cannot be written. For example, isReadable(),
       isWritable() and isReadWrite() tell the application whether it can read
       from and write to a given device. (This can often be set by the
       application in the call to open().)

       Finally, isOpen() returns TRUE if the device is open, i.e. after an
       open() call.

       QIODevice provides numerous pure virtual functions that you need to
       implement when subclassing it. Here is a skeleton subclass with all the
       members you are sure to need and some that you will probably need:

	   class MyDevice : public QIODevice
	   {
	   public:
	       MyDevice();
	       ~MyDevice();
	       bool open( int mode );
	       void close();
	       void flush();
	       uint size() const;
	       int  at() const;	       // non-pure virtual
	       bool at( int );	       // non-pure virtual
	       bool atEnd() const;     // non-pure virtual
	       int readBlock( char *data, uint maxlen );
	       int writeBlock( const char *data, uint len );
	       int readLine( char *data, uint maxlen );
	       int getch();
	       int putch( int );
	       int ungetch( int );
	   };

       The three non-pure virtual functions need not be reimplemented for
       sequential devices.

       See also QDataStream, QTextStream, and Input/Output and Networking.

   Member Type Documentation
QIODevice::Offset
       The offset within the device.

MEMBER FUNCTION DOCUMENTATION
QIODevice::QIODevice ()
       Constructs an I/O device.

QIODevice::~QIODevice () [virtual]
       Destroys the I/O device.

Offset QIODevice::at () const [virtual]
       Virtual function that returns the current I/O device position.

       This is the position of the data read/write head of the I/O device.

       See also size().

       Example: distributor/distributor.ui.h.

       Reimplemented in QSocket.

bool QIODevice::at ( Offset pos ) [virtual]
       Virtual function that sets the I/O device position to pos. Returns TRUE
       if the position was successfully set, i.e. pos is within range and the
       seek was successful; otherwise returns FALSE.

       See also size().

       Reimplemented in QSocket.

bool QIODevice::atEnd () const [virtual]
       Virtual function that returns TRUE if the I/O device position is at the
       end of the input; otherwise returns FALSE.

       Reimplemented in QFile and QSocket.

void QIODevice::close () [pure virtual]
       Closes the I/O device.

       This virtual function must be reimplemented by all subclasses.

       See also open().

       Example: grapher/grapher.cpp.

       Reimplemented in QFile and QSocket.

int QIODevice::flags () const
       Returns the current I/O device flags setting.

       Flags consists of mode flags and state flags.

       See also mode() and state().

void QIODevice::flush () [pure virtual]
       Flushes an open I/O device.

       This virtual function must be reimplemented by all subclasses.

       Reimplemented in QFile and QSocket.

int QIODevice::getch () [pure virtual]
       Reads a single byte/character from the I/O device.

       Returns the byte/character read, or -1 if the end of the I/O device has
       been reached.

       This virtual function must be reimplemented by all subclasses.

       See also putch() and ungetch().

       Reimplemented in QFile and QSocket.

bool QIODevice::isAsynchronous () const
       Returns TRUE if the device is an asynchronous device; otherwise returns
       FALSE, i.e. if the device is a synchronous device.

       This mode is currently not in use.

       See also isSynchronous().

bool QIODevice::isBuffered () const
       Returns TRUE if the I/O device is a buffered device; otherwise returns
       FALSE, i.e. the device is a raw device.

       See also isRaw().

bool QIODevice::isCombinedAccess () const
       Returns TRUE if the I/O device is a combined access (both direct and
       sequential) device; otherwise returns FALSE.

       This access method is currently not in use.

bool QIODevice::isDirectAccess () const
       Returns TRUE if the I/O device is a direct access device; otherwise
       returns FALSE, i.e. if the device is a sequential access device.

       See also isSequentialAccess().

bool QIODevice::isInactive () const
       Returns TRUE if the I/O device state is 0, i.e. the device is not open;
       otherwise returns FALSE.

       See also isOpen().

bool QIODevice::isOpen () const
       Returns TRUE if the I/O device has been opened; otherwise returns
       FALSE.

       See also isInactive().

       Example: network/networkprotocol/nntp.cpp.

bool QIODevice::isRaw () const
       Returns TRUE if the device is a raw device; otherwise returns FALSE,
       i.e. if the device is a buffered device.

       See also isBuffered().

bool QIODevice::isReadWrite () const
       Returns TRUE if the I/O device was opened using IO_ReadWrite mode;
       otherwise returns FALSE.

       See also isReadable() and isWritable().

bool QIODevice::isReadable () const
       Returns TRUE if the I/O device was opened using IO_ReadOnly or
       IO_ReadWrite mode; otherwise returns FALSE.

       See also isWritable() and isReadWrite().

bool QIODevice::isSequentialAccess () const
       Returns TRUE if the device is a sequential access device; otherwise
       returns FALSE, i.e. if the device is a direct access device.

       Operations involving size() and at(int) are not valid on sequential
       devices.

       See also isDirectAccess().

bool QIODevice::isSynchronous () const
       Returns TRUE if the I/O device is a synchronous device; otherwise
       returns FALSE, i.e. the device is an asynchronous device.

       See also isAsynchronous().

bool QIODevice::isTranslated () const
       Returns TRUE if the I/O device translates carriage-return and linefeed
       characters; otherwise returns FALSE.

       A QFile is translated if it is opened with the IO_Translate mode flag.

bool QIODevice::isWritable () const
       Returns TRUE if the I/O device was opened using IO_WriteOnly or
       IO_ReadWrite mode; otherwise returns FALSE.

       See also isReadable() and isReadWrite().

int QIODevice::mode () const
       Returns bits OR'ed together that specify the current operation mode.

       These are the flags that were given to the open() function.

       The flags are IO_ReadOnly, IO_WriteOnly, IO_ReadWrite, IO_Append,
       IO_Truncate and IO_Translate.

bool QIODevice::open ( int mode ) [pure virtual]
       Opens the I/O device using the specified mode. Returns TRUE if the
       device was successfully opened; otherwise returns FALSE.

       The mode parameter mode must be an OR'ed combination of the following
       flags. <center>.nf

       </center>

       This virtual function must be reimplemented by all subclasses.

       See also close().

       Example: grapher/grapher.cpp.

       Reimplemented in QFile and QSocket.

int QIODevice::putch ( int ch ) [pure virtual]
       Writes the character ch to the I/O device.

       Returns ch, or -1 if an error occurred.

       This virtual function must be reimplemented by all subclasses.

       See also getch() and ungetch().

       Example: grapher/grapher.cpp.

       Reimplemented in QFile and QSocket.

QByteArray QIODevice::readAll () [virtual]
       This convenience function returns all of the remaining data in the
       device.

Q_LONG QIODevice::readBlock ( char * data, Q_ULONG maxlen ) [pure virtual]
       Reads at most maxlen bytes from the I/O device into data and returns
       the number of bytes actually read.

       This function should return -1 if a fatal error occurs and should
       return 0 if there are no bytes to read.

       The device must be opened for reading, and data must not be 0.

       This virtual function must be reimplemented by all subclasses.

       See also writeBlock(), isOpen(), and isReadable().

       Example: distributor/distributor.ui.h.

       Reimplemented in QSocket and QSocketDevice.

Q_LONG QIODevice::readLine ( char * data, Q_ULONG maxlen ) [virtual]
       Reads a line of text, (or up to maxlen bytes if a newline isn't
       encountered) plus a terminating '\0' into data. If there is a
       newline at the end if the line, it is not stripped.

       Returns the number of bytes read including the terminating '\0', or
       -1 if an error occurred.

       This virtual function can be reimplemented much more efficiently by the
       most subclasses.

       See also readBlock() and QTextStream::readLine().

       Reimplemented in QFile.

bool QIODevice::reset ()
       Sets the device index position to 0.

       See also at().

void QIODevice::resetStatus ()
       Sets the I/O device status to IO_Ok.

       See also status().

void QIODevice::setFlags ( int flags ) [protected]
       Used by subclasses to set the device flags to the flags specified.

void QIODevice::setMode ( int mode ) [protected]
       Used by subclasses to set the device mode to the mode specified.

void QIODevice::setState ( int state ) [protected]
       Used by subclasses to set the device state to the state specified.

void QIODevice::setStatus ( int s ) [protected]
       Used by subclasses to set the device status (not state) to s.

void QIODevice::setType ( int type ) [protected]
       Used by subclasses to set the device type to the type specified.

Offset QIODevice::size () const [pure virtual]
       Virtual function that returns the size of the I/O device.

       See also at().

       Reimplemented in QFile and QSocket.

int QIODevice::state () const
       Returns bits OR'ed together that specify the current state.

       The flags are: IO_Open.

       Subclasses may define additional flags.

int QIODevice::status () const
       Returns the I/O device status.

       The I/O device status returns an error code. If open() returns FALSE or
       readBlock() or writeBlock() return -1, this function can be called to
       find out the reason why the operation failed.

       The status codes are: <center>.nf

       </center>

       See also resetStatus().

int QIODevice::ungetch ( int ch ) [pure virtual]
       Puts the character ch back into the I/O device and decrements the index
       position if it is not zero.

       This function is normally called to "undo" a getch() operation.

       Returns ch, or -1 if an error occurred.

       This virtual function must be reimplemented by all subclasses.

       See also getch() and putch().

       Reimplemented in QFile and QSocket.

Q_LONG QIODevice::writeBlock ( const char * data, Q_ULONG len ) [pure virtual]

       Writes len bytes from data to the I/O device and returns the number of
       bytes actually written.

       This function should return -1 if a fatal error occurs.

       This virtual function must be reimplemented by all subclasses.

       See also readBlock().

       Example: distributor/distributor.ui.h.

       Reimplemented in QBuffer, QSocket, and QSocketDevice.

Q_LONG QIODevice::writeBlock ( const QByteArray & data )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       This convenience function is the same as calling writeBlock(
       data.data(), data.size() ).

SEE ALSO
       http://doc.trolltech.com/qiodevice.html
       http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2007 Trolltech ASA, http://www.trolltech.com.  See the
       license file included in the distribution for a complete license
       statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to
       help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is
       located at $QTDIR/doc/html and can be read using Qt Assistant or with a
       web browser. This man page is provided as a convenience for those users
       who prefer man pages, although this format is not officially supported
       by Trolltech.

       If you find errors in this manual page, please report them to qt-
       bugs@trolltech.com.  Please include the name of the manual page
       (qiodevice.3qt) and the Qt version (3.3.8).

Trolltech AS			2 February 2007			QIODevice(3qt)
[top]

List of man pages available for Peanut

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net