The QBuffer class is an I/O device that operates on a QByteArray. More...

#include <qbuffer.h>

Inheritance diagram for QBuffer:

Public Member Functions
	QBuffer ()

	QBuffer (QByteArray)

	~QBuffer ()

QByteArray	buffer () const

bool	setBuffer (QByteArray)

bool	open (int)

void	close ()

void	flush ()

uint	size () const

int	at () const

bool	at (int)

int	readBlock (char *p, uint)

int	writeBlock (const char *p, uint)

int	readLine (char *p, uint)

int	getch ()

int	putch (int)

int	ungetch (int)

Public Member Functions inherited from QIODevice
	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	atEnd () const

bool	reset ()

int	writeBlock (const QByteArray &data)

QByteArray	readAll ()

Protected Attributes
QByteArray	a

Protected Attributes inherited from QIODevice
int	ioIndex

Private Member Functions
	QBuffer (const QBuffer &)

QBuffer &	operator= (const QBuffer &)

Private Attributes
uint	a_len

uint	a_inc

Additional Inherited Members
Protected Member Functions inherited from QIODevice
void	setFlags (int f)

void	setType (int)

void	setMode (int)

void	setState (int)

void	setStatus (int)

Detailed Description

The QBuffer class is an I/O device that operates on a QByteArray.

QBuffer allows reading and writing a memory buffer. It is normally used together with a QTextStream or a QDataStream. QBuffer has an associated QByteArray which holds the buffer data. The size() of the buffer is automatically adjusted as data is written.

The constructor QBuffer(QByteArray) creates a QBuffer with an existing byte array. The byte array can also be set with setBuffer(). Writing to the QBuffer will modify the original byte array, since QByteArray is explicitly shared.

Use open() to open the buffer before use, and to set the mode (read-only,write-only, etc.). close() closes the buffer. The buffer must be closed before reopening or calling setBuffer().

The common way to use QBuffer is through QDataStream or QTextStream which have constructors that take a QBuffer parameter. For convenience, there are also QDataStream and QTextStream constructors that take a QByteArray parameter. These constructors create and open an internal QBuffer.

Note that QTextStream can also operate on a QString (a Unicode string); a QBuffer cannot.

You can also use QBuffer directly through the standard QIODevice functions readBlock(), writeBlock() readLine(), at(), getch(), putch() and ungetch().

See also: QFile, QDataStream, QTextStream, QByteArray, Shared Classes

Definition at line 47 of file qbuffer.h.

Constructor & Destructor Documentation

QBuffer::QBuffer ( )

Constructs an empty buffer.

Definition at line 83 of file qbuffer.cpp.

 {
     setFlags( IO_Direct );
     a_inc = 16;                                 // initial increment
     a_len = 0;
     ioIndex = 0;
 }

QBuffer::QBuffer ( QByteArray buf )

Constructs a buffer that operates on buf. If you open the buffer in write mode (IO_WriteOnly or IO_ReadWrite) and write something into the buffer, buf will be modified.

Example:

QCString str = "abc";
QBuffer b( str );
b.open( IO_WriteOnly );
b.at( 3 );                                    // position at \0
b.writeBlock( "def", 4 );                     // write including \0
b.close();
  // Now, str == "abcdef"

See also: setBuffer()

Definition at line 114 of file qbuffer.cpp.

                                  : a(buf)
 {
     setFlags( IO_Direct );
     a_len = a.size();
     a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
     if ( a_inc < 16 )
         a_inc = 16;
     ioIndex = 0;
 }

QBuffer::~QBuffer ( )

Destructs the buffer.

Definition at line 128 of file qbuffer.cpp.

129 {

130 }

QBuffer::QBuffer ( const QBuffer & )

private

Member Function Documentation

int QBuffer::at ( ) const

inlinevirtual

Reimplemented from QIODevice.

Definition at line 94 of file qbuffer.h.

95 { return ioIndex; }

QIODevice::ioIndex

int ioIndex

Definition: qiodevice.h:141

bool QBuffer::at ( int pos )

virtual

Reimplemented from QIODevice.

Definition at line 251 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     if ( !isOpen() ) {
         qWarning( "QBuffer::at: Buffer is not open" );
         return FALSE;
     }
 #endif
     if ( (uint)pos > a_len ) {
 #if defined(CHECK_RANGE)
         qWarning( "QBuffer::at: Index %d out of range", pos );
 #endif
         return FALSE;
     }
     ioIndex = pos;
     return TRUE;
 }

QByteArray QBuffer::buffer ( ) const

inline

Returns this buffer's byte array.

See also: setBuffer()

Definition at line 88 of file qbuffer.h.

89 { return a; }

QBuffer::a

QByteArray a

Definition: qbuffer.h:74

void QBuffer::close ( )

virtual

Closes an open buffer.

See also: open()

Implements QIODevice.

Definition at line 217 of file qbuffer.cpp.

 {
     if ( isOpen() ) {
         setFlags( IO_Direct );
         ioIndex = 0;
         a_inc = 16;
     }
 }

void QBuffer::flush ( )

virtual

The flush function does nothing for a QBuffer.

Implements QIODevice.

Definition at line 231 of file qbuffer.cpp.

 {
     return;
 }

int QBuffer::getch ( )

virtual

Implements QIODevice.

Definition at line 387 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::getch: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::getch: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( (uint)ioIndex+1 > a.size() ) {         // overflow
         setStatus( IO_ReadError );
         return -1;
     }
     return uchar(*(a.data()+ioIndex++));
 }

bool QBuffer::open ( int m )

virtual

Opens the buffer in the mode m. Returns TRUE if successful, otherwise FALSE. The buffer must be opened before use.

The mode parameter m must be a combination of the following flags.

IO_ReadOnly opens a buffer in read-only mode.
IO_WriteOnly opens a buffer in write-only mode.
IO_ReadWrite opens a buffer in read/write mode.
IO_Append sets the buffer index to the end of the buffer.
IO_Truncate truncates the buffer.

See also: close(), isOpen()

Implements QIODevice.

Definition at line 187 of file qbuffer.cpp.

 {
     if ( isOpen() ) {                           // buffer already open
 #if defined(CHECK_STATE)
         qWarning( "QBuffer::open: Buffer already open" );
 #endif
         return FALSE;
     }
     setMode( m );
     if ( m & IO_Truncate ) {                    // truncate buffer
         a.resize( 0 );
         a_len = 0;
     }
     if ( m & IO_Append ) {                      // append to end of buffer
         ioIndex = a.size();
     } else {
         ioIndex = 0;
     }
     a_inc = 16;
     setState( IO_Open );
     setStatus( 0 );
     return TRUE;
 }

QBuffer& QBuffer::operator= ( const QBuffer & )

private

int QBuffer::putch ( int ch )

virtual

Writes the character ch into the buffer, overwriting the character at the current index, extending the buffer if necessary.

Returns ch, or -1 if some error occurred.

See also: getch(), ungetch()

Implements QIODevice.

Definition at line 417 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::putch: Buffer not open" );
         return -1;
     }
     if ( !isWritable() ) {                      // writing not permitted
         qWarning( "QBuffer::putch: Write operation not permitted" );
         return -1;
     }
 #endif
     if ( (uint)ioIndex + 1 >= a_len ) {         // overflow
         char buf[1];
         buf[0] = (char)ch;
         if ( writeBlock(buf,1) != 1 )
             return -1;                          // write error
     } else {
         *(a.data() + ioIndex++) = (char)ch;
         if ( a.shd->len < (uint)ioIndex )
             a.shd->len = (uint)ioIndex;
     }
     return ch;
 }

int QBuffer::readBlock	(	char *	p,
		uint	len
	)

virtual

Implements QIODevice.

Definition at line 274 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     CHECK_PTR( p );
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::readBlock: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::readBlock: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( (uint)ioIndex + len > a.size() ) {     // overflow
         if ( (uint)ioIndex >= a.size() ) {
             setStatus( IO_ReadError );
             return -1;
         } else {
             len = a.size() - (uint)ioIndex;
         }
     }
     memcpy( p, a.data()+ioIndex, len );
     ioIndex += len;
     return len;
 }

int QBuffer::readLine	(	char *	p,
		uint	maxlen
	)

virtual

Reimplemented from QIODevice.

Definition at line 353 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     CHECK_PTR( p );
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::readLine: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::readLine: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( maxlen == 0 )
         return 0;
     uint start = (uint)ioIndex;
     char *d = a.data() + ioIndex;
     maxlen--;                                   // make room for 0-terminator
     if ( a.size() - (uint)ioIndex < maxlen )
         maxlen = a.size() - (uint)ioIndex;
     while ( maxlen-- ) {
         if ( (*p++ = *d++) == '\n' )
             break;
     }
     *p = '\0';
     ioIndex = (int)(d - a.data());
     return (uint)ioIndex - start;
 }

bool QBuffer::setBuffer ( QByteArray buf )

Replaces the buffer's contents with buf.

This may not be done when isOpen() is TRUE.

Note that if you open the buffer in write mode (IO_WriteOnly or IO_ReadWrite) and write something into the buffer, buf is also modified because QByteArray is an explicitly shared class.

See also: buffer(), open(), close()

Definition at line 145 of file qbuffer.cpp.

 {
     if ( isOpen() ) {
 #if defined(CHECK_STATE)
         qWarning( "QBuffer::setBuffer: Buffer is open");
 #endif
         return FALSE;
     }
     a = buf;
     a_len = a.size();
     a_inc = (a_len > 512) ? 512 : a_len;        // initial increment
     if ( a_inc < 16 )
         a_inc = 16;
     ioIndex = 0;
     return TRUE;
 }

uint QBuffer::size ( ) const

inlinevirtual

Implements QIODevice.

Definition at line 91 of file qbuffer.h.

92 { return a.size(); }

QBuffer::a

QByteArray a

Definition: qbuffer.h:74

QArray::size

uint size() const

Definition: qarray.h:65

int QBuffer::ungetch ( int ch )

virtual

Implements QIODevice.

Definition at line 446 of file qbuffer.cpp.

 {
 #if defined(CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::ungetch: Buffer not open" );
         return -1;
     }
     if ( !isReadable() ) {                      // reading not permitted
         qWarning( "QBuffer::ungetch: Read operation not permitted" );
         return -1;
     }
 #endif
     if ( ch != -1 ) {
         if ( ioIndex )
             ioIndex--;
         else
             ch = -1;
     }
     return ch;
 }

int QBuffer::writeBlock	(	const char *	p,
		uint	len
	)

virtual

Writes len bytes from p into the buffer at the current index, overwriting any characters there and extending the buffer if necessary. Returns the number of bytes actually written.

Returns -1 if a serious error occurred.

See also: readBlock()

Implements QIODevice.

Definition at line 312 of file qbuffer.cpp.

 {
 #if defined(CHECK_NULL)
     if ( p == 0 && len != 0 )
         qWarning( "QBuffer::writeBlock: Null pointer error" );
 #endif
 #if defined(CHECK_STATE)
     if ( !isOpen() ) {                          // buffer not open
         qWarning( "QBuffer::writeBlock: Buffer not open" );
         return -1;
     }
     if ( !isWritable() ) {                      // writing not permitted
         qWarning( "QBuffer::writeBlock: Write operation not permitted" );
         return -1;
     }
 #endif
     if ( (uint)ioIndex + len >= a_len ) {               // overflow
         uint new_len = a_len + a_inc*(((uint)ioIndex+len-a_len)/a_inc+1);
         if ( !a.resize( new_len ) ) {           // could not resize
 #if defined(CHECK_NULL)
             qWarning( "QBuffer::writeBlock: Memory allocation error" );
 #endif
             setStatus( IO_ResourceError );
             return -1;
         }
         a_inc *= 2;                             // double increment
         a_len = new_len;
         a.shd->len = (uint)ioIndex + len;
     }
     memcpy( a.data()+ioIndex, p, len );
     ioIndex += len;
     if ( a.shd->len < (uint)ioIndex )
         a.shd->len = (uint)ioIndex;             // fake (not alloc'd) length
     return len;
 }

Member Data Documentation

QByteArray QBuffer::a

protected

Definition at line 74 of file qbuffer.h.

uint QBuffer::a_inc

private

Definition at line 78 of file qbuffer.h.

uint QBuffer::a_len

private

Definition at line 77 of file qbuffer.h.

The documentation for this class was generated from the following files:

doxygen-1.8.11/qtools/qbuffer.h
doxygen-1.8.11/qtools/qbuffer.cpp

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation