QGArray Class Reference

The QGArray class is an internal class for implementing the QArray class. More...

#include <qgarray.h>

Inheritance diagram for QGArray:

Classes
struct	array_data

Public Member Functions
	QGArray ()

Protected Member Functions
	QGArray (int, int)
	QGArray (int size)
	QGArray (const QGArray &a)
virtual	~QGArray ()
QGArray &	operator= (const QGArray &a)
virtual void	detach ()
char *	data () const
uint	nrefs () const
uint	size () const
bool	isEqual (const QGArray &a) const
bool	resize (uint newsize)
bool	fill (const char *d, int len, uint sz)
QGArray &	assign (const QGArray &a)
QGArray &	assign (const char *d, uint len)
QGArray &	duplicate (const QGArray &a)
QGArray &	duplicate (const char *d, uint len)
void	store (const char *d, uint len)
array_data *	sharedBlock () const
void	setSharedBlock (array_data *p)
QGArray &	setRawData (const char *d, uint len)
void	resetRawData (const char *d, uint len)
int	find (const char *d, uint index, uint sz) const
int	contains (const char *d, uint sz) const
void	sort (uint sz)
int	bsearch (const char *d, uint sz) const
char *	at (uint index) const
bool	setExpand (uint index, const char *d, uint sz)
virtual array_data *	newData ()
virtual void	deleteData (array_data *p)

Static Private Member Functions
static void	msg_index (uint)

Private Attributes
array_data *	shd

Friends
class	QBuffer

Detailed Description

The QGArray class is an internal class for implementing the QArray class.

QGArray is a strictly internal class that acts as base class for the QArray template array.

It contains an array of bytes and has no notion of an array element.

Definition at line 46 of file qgarray.h.

Constructor & Destructor Documentation

QGArray::QGArray

(

)

Definition at line 89 of file qgarray.cpp.

{
    shd = newData();
    CHECK_PTR( shd );
}

QGArray::QGArray ( int  , int    )

protected

Definition at line 103 of file qgarray.cpp.

{
}

QGArray::QGArray ( int  size )

protected

Definition at line 112 of file qgarray.cpp.

{
    if ( size < 0 ) {
#if defined(CHECK_RANGE)
        qWarning( "QGArray: Cannot allocate array with negative length" );
#endif
        size = 0;
    }
    shd = newData();
    CHECK_PTR( shd );
    if ( size == 0 )                            // zero length
        return;
    shd->data = NEW(char,size);
    CHECK_PTR( shd->data );
    shd->len = size;
}

QGArray::QGArray ( const QGArray &  a )

protected

Definition at line 134 of file qgarray.cpp.

{
    shd = a.shd;
    shd->ref();
}

QGArray::~QGArray ( )

protectedvirtual

Definition at line 146 of file qgarray.cpp.

{
    if ( shd && shd->deref() ) {                // delete when last reference
        if ( shd->data )                        // is lost
            DELETE(shd->data);
        deleteData( shd );
    }
}

Member Function Documentation

QGArray & QGArray::assign ( const QGArray &  a )

protected

Definition at line 284 of file qgarray.cpp.

{
    a.shd->ref();                               // avoid 'a = a'
    if ( shd->deref() ) {                       // delete when last reference
        if ( shd->data )                        // is lost
            DELETE(shd->data);
        deleteData( shd );
    }
    shd = a.shd;
    return *this;
}

QGArray & QGArray::assign ( const char *  d, uint  len  )

protected

Definition at line 305 of file qgarray.cpp.

{
    if ( shd->count > 1 ) {                     // disconnect this
        shd->count--;
        shd = newData();
        CHECK_PTR( shd );
    } else {
        if ( shd->data )
            DELETE(shd->data);
    }
    shd->data = (char *)d;
    shd->len = len;
    return *this;
}

char * QGArray::at ( uint  index ) const

inlineprotected

Definition at line 108 of file qgarray.h.

{
#if defined(CHECK_RANGE)
    if ( index >= size() ) {
        msg_index( index );
        index = 0;
    }
#endif
    return &shd->data[index];
}

int QGArray::bsearch ( const char *  d, uint  sz  ) const

protected

Definition at line 667 of file qgarray.cpp.

{
    int numItems = size() / sz;
    if ( !numItems )
        return -1;
    cmp_item_size = sz;
    char* r = (char*)::bsearch( d, shd->data, numItems, sz, cmp_arr );
    if ( !r )
        return -1;
    while( (r >= shd->data + sz) && (cmp_arr( r - sz, d ) == 0) )
        r -= sz;        // search to first of equal elements; bsearch is undef 
    return (int)(( r - shd->data ) / sz);
}

int QGArray::contains ( const char *  d, uint  sz  ) const

protected

Definition at line 584 of file qgarray.cpp.

{
    register uint i = shd->len;
    int count = 0;
    switch ( sz ) {
        case 1: {                               // 8 bit elements
            register char *x = data();
            char v = *d;
            while ( i-- ) {
                if ( *x++ == v )
                    count++;
            }
            }
            break;
        case 2: {                               // 16 bit elements
            register Q_INT16 *x = (Q_INT16*)data();
            Q_INT16 v = *((Q_INT16*)d);
            i /= 2;
            while ( i-- ) {
                if ( *x++ == v )
                    count++;
            }
            }
            break;
        case 4: {                               // 32 bit elements
            register Q_INT32 *x = (Q_INT32*)data();
            Q_INT32 v = *((Q_INT32*)d);
            i /= 4;
            while ( i-- ) {
                if ( *x++ == v )
                    count++;
            }
            }
            break;
        default: {                              // any size elements
            for ( i=0; i<shd->len; i+=sz ) {
                if ( memcmp(d, &shd->data[i], sz) == 0 )
                    count++;
            }
            }
            break;
    }
    return count;
}

char * QGArray::data ( ) const

inlineprotected

Definition at line 67 of file qgarray.h.

{ return shd->data; }

void QGArray::deleteData ( array_data *  p )

protectedvirtual

Definition at line 743 of file qgarray.cpp.

{
    delete p;
    p = 0;
}

void QGArray::detach ( )

inlineprotectedvirtual

Reimplemented in QArray< type >, QArray< char >, and QArray< bool >.

Definition at line 65 of file qgarray.h.

{ duplicate(*this); }

QGArray & QGArray::duplicate ( const QGArray &  a )

protected

Definition at line 327 of file qgarray.cpp.

{
    if ( a.shd == shd ) {                       // a.duplicate(a) !
        if ( shd->count > 1 ) {
            shd->count--;
            register array_data *n = newData();
            CHECK_PTR( n );
            if ( (n->len=shd->len) ) {
                n->data = NEW(char,n->len);
                CHECK_PTR( n->data );
                if ( n->data )
                    memcpy( n->data, shd->data, n->len );
            } else {
                n->data = 0;
            }
            shd = n;
        }
        return *this;
    }
    char *oldptr = 0;
    if ( shd->count > 1 ) {                     // disconnect this
        shd->count--;
        shd = newData();
        CHECK_PTR( shd );
    } else {                                    // delete after copy was made
        oldptr = shd->data;
    }
    if ( a.shd->len ) {                         // duplicate data
        shd->data = NEW(char,a.shd->len);
        CHECK_PTR( shd->data );
        if ( shd->data )
            memcpy( shd->data, a.shd->data, a.shd->len );
    } else {
        shd->data = 0;
    }
    shd->len = a.shd->len;
    if ( oldptr )
        DELETE(oldptr);
    return *this;
}

QGArray & QGArray::duplicate ( const char *  d, uint  len  )

protected

Definition at line 375 of file qgarray.cpp.

{
    char *data;
    if ( d == 0 || len == 0 ) {
        data = 0;
        len  = 0;
    } else {
        if ( shd->count == 1 && shd->len == len ) {
            memcpy( shd->data, d, len );        // use same buffer
            return *this;
        }
        data = NEW(char,len);
        CHECK_PTR( data );
        memcpy( data, d, len );
    }
    if ( shd->count > 1 ) {                     // detach
        shd->count--;
        shd = newData();
        CHECK_PTR( shd );
    } else {                                    // just a single reference
        if ( shd->data )
            DELETE(shd->data);
    }
    shd->data = data;
    shd->len  = len;
    return *this;
}

bool QGArray::fill ( const char *  d, int  len, uint  sz  )

protected

Definition at line 249 of file qgarray.cpp.

{
    if ( len < 0 )
        len = shd->len/sz;                      // default: use array length
    else if ( !resize( len*sz ) )
        return FALSE;
    if ( sz == 1 )                              // 8 bit elements
        memset( data(), *d, len );
    else if ( sz == 4 ) {                       // 32 bit elements
        register Q_INT32 *x = (Q_INT32*)data();
        Q_INT32 v = *((Q_INT32*)d);
        while ( len-- )
            *x++ = v;
    } else if ( sz == 2 ) {                     // 16 bit elements
        register Q_INT16 *x = (Q_INT16*)data();
        Q_INT16 v = *((Q_INT16*)d);
        while ( len-- )
            *x++ = v;
    } else {                                    // any other size elements
        register char *x = data();
        while ( len-- ) {                       // more complicated
            memcpy( x, d, sz );
            x += sz;
        }
    }
    return TRUE;
}

int QGArray::find ( const char *  d, uint  index, uint  sz  ) const

protected

Definition at line 522 of file qgarray.cpp.

{
    index *= sz;
    if ( index >= shd->len ) {
#if defined(CHECK_RANGE)
        qWarning( "QGArray::find: Index %d out of range", index/sz );
#endif
        return -1;
    }
    register uint i;
    uint ii;
    switch ( sz ) {
        case 1: {                               // 8 bit elements
            register char *x = data() + index;
            char v = *d;
            for ( i=index; i<shd->len; i++ ) {
                if ( *x++ == v )
                    break;
            }
            ii = i;
            }
            break;
        case 2: {                               // 16 bit elements
            register Q_INT16 *x = (Q_INT16*)(data() + index);
            Q_INT16 v = *((Q_INT16*)d);
            for ( i=index; i<shd->len; i+=2 ) {
                if ( *x++ == v )
                    break;
            }
            ii = i/2;
            }
            break;
        case 4: {                               // 32 bit elements
            register Q_INT32 *x = (Q_INT32*)(data() + index);
            Q_INT32 v = *((Q_INT32*)d);
            for ( i=index; i<shd->len; i+=4 ) {
                if ( *x++ == v )
                    break;
            }
            ii = i/4;
            }
            break;
        default: {                              // any size elements
            for ( i=index; i<shd->len; i+=sz ) {
                if ( memcmp( d, &shd->data[i], sz ) == 0 )
                    break;
            }
            ii = i/sz;
            }
            break;
    }
    return i<shd->len ? (int)ii : -1;
}

bool QGArray::isEqual ( const QGArray &  a ) const

protected

Definition at line 194 of file qgarray.cpp.

{
    if ( size() != a.size() )                   // different size
        return FALSE;
    if ( data() == a.data() )                   // has same data
        return TRUE;
    return (size() ? memcmp( data(), a.data(), size() ) : 0) == 0;
}

void QGArray::msg_index ( uint  index )

staticprivate

Definition at line 717 of file qgarray.cpp.

{
#if defined(CHECK_RANGE)
    qWarning( "QGArray::at: Absolute index %d out of range", index );
#else
    Q_UNUSED( index )
#endif
}

QGArray::array_data * QGArray::newData ( )

protectedvirtual

Definition at line 732 of file qgarray.cpp.

{
    return new array_data;
}

uint QGArray::nrefs ( ) const

inlineprotected

Definition at line 68 of file qgarray.h.

{ return shd->count; }

QGArray & QGArray::operator= ( const QGArray &  a )

inlineprotected

Definition at line 63 of file qgarray.h.

{ return assign( a ); }

void QGArray::resetRawData ( const char *  d, uint  len  )

protected

Definition at line 499 of file qgarray.cpp.

{
    if ( d != shd->data || len != shd->len ) {
#if defined(CHECK_STATE)
        qWarning( "QGArray::resetRawData: Inconsistent arguments" );
#endif
        return;
    }
    shd->data = 0;
    shd->len  = 0;
}

bool QGArray::resize ( uint  newsize )

protected

Definition at line 209 of file qgarray.cpp.

{
    if ( newsize == shd->len )                  // nothing to do
        return TRUE;
    if ( newsize == 0 ) {                       // remove array
        duplicate( 0, 0 );
        return TRUE;
    }
    if ( shd->data ) {                          // existing data
#if defined(DONT_USE_REALLOC)
        char *newdata = NEW(char,newsize);      // manual realloc
        memcpy( newdata, shd->data, QMIN(shd->len,newsize) );
        DELETE(shd->data);
        shd->data = newdata;
#else
        shd->data = (char *)realloc( shd->data, newsize );
#endif
    } else {
        shd->data = NEW(char,newsize);
    }
    CHECK_PTR( shd->data );
    if ( !shd->data )                           // no memory
        return FALSE;
    shd->len = newsize;
    return TRUE;
}

bool QGArray::setExpand ( uint  index, const char *  d, uint  sz  )

protected

Definition at line 700 of file qgarray.cpp.

{
    index *= sz;
    if ( index >= shd->len ) {
        if ( !resize( index+sz ) )              // no memory
            return FALSE;
    }
    memcpy( data() + index, d, sz );
    return TRUE;
}

QGArray & QGArray::setRawData ( const char *  d, uint  len  )

protected

Definition at line 483 of file qgarray.cpp.

{
    duplicate( 0, 0 );                          // set null data
    shd->data = (char *)d;
    shd->len  = len;
    return *this;
}

void QGArray::setSharedBlock ( array_data *  p )

inlineprotected

Definition at line 83 of file qgarray.h.

{ shd=(array_data*)p; }

array_data * QGArray::sharedBlock ( ) const

inlineprotected

Definition at line 82 of file qgarray.h.

{ return shd; }

uint QGArray::size ( ) const

inlineprotected

Definition at line 69 of file qgarray.h.

{ return shd->len; }

void QGArray::sort ( uint  sz )

protected

Definition at line 652 of file qgarray.cpp.

{
    int numItems = size() / sz;
    if ( numItems < 2 )
        return;
    cmp_item_size = sz;
    qsort( shd->data, numItems, sz, cmp_arr );
}

void QGArray::store ( const char *  d, uint  len  )

protected

Definition at line 412 of file qgarray.cpp.

{                                               // store, but not deref
    resize( len );
    memcpy( shd->data, d, len );
}

Friends And Related Function Documentation

friend class QBuffer

friend

Definition at line 48 of file qgarray.h.

Member Data Documentation

array_data* QGArray::shd

private

Definition at line 104 of file qgarray.h.

---

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

• doxygen-1.8.11/qtools/qgarray.h
• doxygen-1.8.11/qtools/qgarray.cpp