From ea318d1431c89e647598c510c4245c6571aa5f46 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Thu, 26 Jan 2012 23:32:43 -0600 Subject: Update to latest tqt3 automated conversion --- doc/html/ntqiodevice.html | 553 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 553 insertions(+) create mode 100644 doc/html/ntqiodevice.html (limited to 'doc/html/ntqiodevice.html') diff --git a/doc/html/ntqiodevice.html b/doc/html/ntqiodevice.html new file mode 100644 index 000000000..16b77679f --- /dev/null +++ b/doc/html/ntqiodevice.html @@ -0,0 +1,553 @@ + + + + + +TQIODevice Class + + + + + + + +
+ +Home + | +All Classes + | +Main Classes + | +Annotated + | +Grouped Classes + | +Functions +

TQIODevice Class Reference

+ +

The TQIODevice class is the base class of I/O devices. +More... +

All the functions in this class are reentrant when TQt is built with thread support.

+

#include <ntqiodevice.h> +

Inherited by TQBuffer, TQFile, TQSocket, and TQSocketDevice. +

List of all member functions. +

Public Members

+ +

Protected Members

+ +

Detailed Description

+ + + +

The TQIODevice 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 TQIODevice class is the abstract +superclass of all such devices; classes such as TQFile, TQBuffer and +TQSocket inherit TQIODevice and implement virtual functions such as +write() appropriately. +

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

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

+

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

+

The state access are all "get" functions. The TQIODevice 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: +

+

TQIODevice 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 TQIODevice
+    {
+    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 TQDataStream, TQTextStream, and Input/Output and Networking. + +

Member Type Documentation

+

TQIODevice::Offset

+ +

The offset within the device. + +

Member Function Documentation

+

TQIODevice::TQIODevice () +

+Constructs an I/O device. + +

TQIODevice::~TQIODevice () [virtual] +

+Destroys the I/O device. + +

Offset TQIODevice::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 TQSocket. +

bool TQIODevice::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 TQSocket. +

bool TQIODevice::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 TQFile and TQSocket. +

void TQIODevice::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 TQFile and TQSocket. +

int TQIODevice::flags () const +

+ +

Returns the current I/O device flags setting. +

Flags consists of mode flags and state flags. +

See also mode() and state(). + +

void TQIODevice::flush () [pure virtual] +

+ +

Flushes an open I/O device. +

This virtual function must be reimplemented by all subclasses. + +

Reimplemented in TQFile and TQSocket. +

int TQIODevice::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 TQFile and TQSocket. +

bool TQIODevice::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 TQIODevice::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 TQIODevice::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 TQIODevice::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 TQIODevice::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 TQIODevice::isOpen () const +

+ +

Returns TRUE if the I/O device has been opened; otherwise returns +FALSE. +

See also isInactive(). + +

Example: network/networkprotocol/nntp.cpp. +

bool TQIODevice::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 TQIODevice::isReadWrite () const +

+ +

Returns TRUE if the I/O device was opened using IO_ReadWrite +mode; otherwise returns FALSE. +

See also isReadable() and isWritable(). + +

bool TQIODevice::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 TQIODevice::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 TQIODevice::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 TQIODevice::isTranslated () const +

+ +

Returns TRUE if the I/O device translates carriage-return and +linefeed characters; otherwise returns FALSE. +

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

bool TQIODevice::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 TQIODevice::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 TQIODevice::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. +

+
Mode flags Meaning +
IO_Raw specifies raw (unbuffered) file access. +
IO_ReadOnly opens a file in read-only mode. +
IO_WriteOnly opens a file in write-only mode. +
IO_ReadWrite opens a file in read/write mode. +
IO_Append sets the file index to the end of the file. +
IO_Truncate truncates the file. +
IO_Translate enables carriage returns and linefeed +translation for text files under MS-DOS, Windows and Macintosh. On +Unix systems this flag has no effect. Use with caution as it will +also transform every linefeed written to the file into a CRLF +pair. This is likely to corrupt your file if you write write +binary data. Cannot be combined with IO_Raw. +
+

This virtual function must be reimplemented by all subclasses. +

See also close(). + +

Example: grapher/grapher.cpp. +

Reimplemented in TQFile and TQSocket. +

int TQIODevice::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 TQFile and TQSocket. +

TQByteArray TQIODevice::readAll () [virtual] +

+This convenience function returns all of the remaining data in the +device. + +

Q_LONG TQIODevice::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 TQSocket and TQSocketDevice. +

Q_LONG TQIODevice::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 TQTextStream::readLine(). + +

Reimplemented in TQFile. +

bool TQIODevice::reset () +

+ +

Sets the device index position to 0. +

See also at(). + +

void TQIODevice::resetStatus () +

+ +

Sets the I/O device status to IO_Ok. +

See also status(). + +

void TQIODevice::setFlags ( int flags ) [protected] +

+ +

Used by subclasses to set the device flags to the flags specified. + +

void TQIODevice::setMode ( int mode ) [protected] +

+ +

Used by subclasses to set the device mode to the mode specified. + +

void TQIODevice::setState ( int state ) [protected] +

+ +

Used by subclasses to set the device state to the state specified. + +

void TQIODevice::setStatus ( int s ) [protected] +

+Used by subclasses to set the device status (not state) to s. + +

void TQIODevice::setType ( int type ) [protected] +

+ +

Used by subclasses to set the device type to the type specified. + +

Offset TQIODevice::size () const [pure virtual] +

+ +

Virtual function that returns the size of the I/O device. +

See also at(). + +

Reimplemented in TQFile and TQSocket. +

int TQIODevice::state () const +

+ +

Returns bits OR'ed together that specify the current state. +

The flags are: IO_Open. +

Subclasses may define additional flags. + +

int TQIODevice::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: +

+
Status code Meaning +
IO_Ok The operation was successful. +
IO_ReadError Could not read from the device. +
IO_WriteError Could not write to the device. +
IO_FatalError A fatal unrecoverable error occurred. +
IO_OpenError Could not open the device. +
IO_ConnectError Could not connect to the device. +
IO_AbortError The operation was unexpectedly aborted. +
IO_TimeOutError The operation timed out. +
IO_UnspecifiedError An unspecified error happened on close. +
+

See also resetStatus(). + +

int TQIODevice::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 TQFile and TQSocket. +

Q_LONG TQIODevice::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 TQBuffer, TQSocket, and TQSocketDevice. +

Q_LONG TQIODevice::writeBlock ( const TQByteArray & 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() ). + + +

+This file is part of the TQt toolkit. +Copyright © 1995-2007 +Trolltech. All Rights Reserved.

+ +
Copyright © 2007 +TrolltechTrademarks +
TQt 3.3.8
+
+ -- cgit v1.2.1