QIODevicePrivateLinearBuffer Class Reference

#include <qiodevice_p.h>

Public Functions
bool	canReadLine () const
void	chop (int size)
void	clear ()
int	getChar ()
bool	isEmpty () const
int	peek (char *target, int size)
	QIODevicePrivateLinearBuffer (int)
int	read (char *target, int size)
QByteArray	readAll ()
int	readLine (char *target, int size)
char *	reserve (int size)
int	size () const
void	skip (int n)
void	ungetBlock (const char *block, int size)
void	ungetChar (char c)
	~QIODevicePrivateLinearBuffer ()

Private Types
enum	FreeSpacePos { freeSpaceAtStart, freeSpaceAtEnd }

Private Functions
void	makeSpace (size_t required, FreeSpacePos where)

Properties
char *	buf
size_t	capacity
char *	first
int	len

Detailed Description

Definition at line 72 of file qiodevice_p.h.

Enumerations

FreeSpacePos

enum QIODevicePrivateLinearBuffer::FreeSpacePos

private

Enumerator
freeSpaceAtStart
freeSpaceAtEnd

Definition at line 170 of file qiodevice_p.h.

{freeSpaceAtStart, freeSpaceAtEnd};

Constructors and Destructors

QIODevicePrivateLinearBuffer()

QIODevicePrivateLinearBuffer::QIODevicePrivateLinearBuffer ( int  )

inline

Definition at line 75 of file qiodevice_p.h.

                                      : len(0), first(0), buf(0), capacity(0) {
    }

~QIODevicePrivateLinearBuffer()

QIODevicePrivateLinearBuffer::~QIODevicePrivateLinearBuffer ( )

inline

Definition at line 77 of file qiodevice_p.h.

                                    {
        delete [] buf;
    }

Functions

canReadLine()

bool QIODevicePrivateLinearBuffer::canReadLine ( ) const

inline

Definition at line 147 of file qiodevice_p.h.

                             {
        return memchr(first, '\n', len);
    }

chop()

void QIODevicePrivateLinearBuffer::chop ( int  size )

inline

Definition at line 124 of file qiodevice_p.h.

                        {
        if (size >= len) {
            clear();
        } else {
            len -= size;
        }
    }

clear()

void QIODevicePrivateLinearBuffer::clear ( )

inline

Definition at line 80 of file qiodevice_p.h.

Referenced by chop(), readAll(), and skip().

                 {
        first = buf;
        len = 0;
    }

getChar()

int QIODevicePrivateLinearBuffer::getChar ( )

inline

Definition at line 98 of file qiodevice_p.h.

                  {
        if (len == 0)
            return -1;
        int ch = uchar(*first);
        len--;
        first++;
        return ch;
    }

isEmpty()

bool QIODevicePrivateLinearBuffer::isEmpty ( ) const

inline

Definition at line 87 of file qiodevice_p.h.

                         {
        return len == 0;
    }

makeSpace()

void QIODevicePrivateLinearBuffer::makeSpace ( size_t  required, FreeSpacePos  where  )

inlineprivate

Definition at line 171 of file qiodevice_p.h.

Referenced by reserve(), ungetBlock(), and ungetChar().

                                                        {
        size_t newCapacity = qMax(capacity, size_t(QIODEVICE_BUFFERSIZE));
        while (newCapacity < required)
            newCapacity *= 2;
        int moveOffset = (where == freeSpaceAtEnd) ? 0 : newCapacity - len;
        if (newCapacity > capacity) {
            // allocate more space
            char* newBuf = new char[newCapacity];
            memmove(newBuf + moveOffset, first, len);
            delete [] buf;
            buf = newBuf;
            capacity = newCapacity;
        } else {
            // shift any existing data to make space
            memmove(buf + moveOffset, first, len);
        }
        first = buf + moveOffset;
    }

peek()

int QIODevicePrivateLinearBuffer::peek ( char *  target, int  size  )

inline

Definition at line 113 of file qiodevice_p.h.

Referenced by QIODevicePrivate::isSequential(), and QSslSocketPrivate::peek().

                                     {
        int r = qMin(size, len);
        memcpy(target, first, r);
        return r;
    }

read()

int QIODevicePrivateLinearBuffer::read ( char *  target, int  size  )

inline

Definition at line 106 of file qiodevice_p.h.

                                     {
        int r = qMin(size, len);
        memcpy(target, first, r);
        len -= r;
        first += r;
        return r;
    }

readAll()

QByteArray QIODevicePrivateLinearBuffer::readAll ( )

inline

Definition at line 131 of file qiodevice_p.h.

                         {
        char* f = first;
        int l = len;
        clear();
        return QByteArray(f, l);
    }

readLine()

int QIODevicePrivateLinearBuffer::readLine ( char *  target, int  size  )

inline

Definition at line 137 of file qiodevice_p.h.

                                         {
        int r = qMin(size, len);
        char* eol = static_cast<char*>(memchr(first, '\n', r));
        if (eol)
            r = 1+(eol-first);
        memcpy(target, first, r);
        len -= r;
        first += r;
        return int(r);
        }

reserve()

char* QIODevicePrivateLinearBuffer::reserve ( int  size )

inline

Definition at line 118 of file qiodevice_p.h.

                            {
        makeSpace(size + len, freeSpaceAtEnd);
        char* writePtr = first + len;
        len += size;
        return writePtr;
    }

size()

int QIODevicePrivateLinearBuffer::size ( ) const

inline

Definition at line 84 of file qiodevice_p.h.

Referenced by chop(), reserve(), and ungetBlock().

                     {
        return len;
    }

skip()

void QIODevicePrivateLinearBuffer::skip ( int  n )

inline

Definition at line 90 of file qiodevice_p.h.

                     {
        if (n >= len) {
            clear();
        } else {
            len -= n;
            first += n;
        }
    }

ungetBlock()

void QIODevicePrivateLinearBuffer::ungetBlock ( const char *  block, int  size  )

inline

Definition at line 159 of file qiodevice_p.h.

                                                 {
        if ((first - buf) < size) {
            // underflow, the existing valid data needs to move to the end of the (potentially bigger) buffer
            makeSpace(len + size, freeSpaceAtStart);
        }
        first -= size;
        len += size;
        memcpy(first, block, size);
    }

ungetChar()

void QIODevicePrivateLinearBuffer::ungetChar ( char  c )

inline

Definition at line 150 of file qiodevice_p.h.

                           {
        if (first == buf) {
            // underflow, the existing valid data needs to move to the end of the (potentially bigger) buffer
            makeSpace(len+1, freeSpaceAtStart);
        }
        first--;
        len++;
        *first = c;
    }

Properties

buf

char* QIODevicePrivateLinearBuffer::buf

private

Definition at line 196 of file qiodevice_p.h.

Referenced by clear(), makeSpace(), ungetBlock(), ungetChar(), and ~QIODevicePrivateLinearBuffer().

capacity

size_t QIODevicePrivateLinearBuffer::capacity

private

Definition at line 198 of file qiodevice_p.h.

Referenced by makeSpace().

first

char* QIODevicePrivateLinearBuffer::first

private

Definition at line 194 of file qiodevice_p.h.

Referenced by canReadLine(), clear(), getChar(), makeSpace(), peek(), read(), readAll(), readLine(), reserve(), skip(), ungetBlock(), and ungetChar().

len

int QIODevicePrivateLinearBuffer::len

private

Definition at line 192 of file qiodevice_p.h.

Referenced by canReadLine(), chop(), clear(), getChar(), isEmpty(), makeSpace(), peek(), read(), readAll(), readLine(), reserve(), size(), skip(), ungetBlock(), and ungetChar().

---

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

• /src/corelib/io/qiodevice_p.h