qgvector.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qgvector.cpp,v 1.2 2003/07/10 02:40:12 llornkcor Exp $
**
** Implementation of QGVector class
**
** Created : 930907
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qglobal.h"
#if defined(Q_CC_BOR)
// needed for qsort() because of a std namespace problem on Borland
#include "qplatformdefs.h"
#endif

#define  QGVECTOR_CPP
#include "qgvector.h"
#include "qglist.h"
#include "qstring.h"
#include "qdatastream.h"
#include <stdlib.h>

#ifdef QT_THREAD_SUPPORT
#  include <private/qmutexpool_p.h>
#endif // QT_THREAD_SUPPORT

#define USE_MALLOC                              // comment to use new/delete

#undef NEW
#undef DELETE

#if defined(USE_MALLOC)
#define NEW(type,size)  ((type*)malloc(size*sizeof(type)))
#define DELETE(array)   (free((char*)array))
#else
#define NEW(type,size)  (new type[size])
#define DELETE(array)   (delete[] array)
#define DONT_USE_REALLOC                        // comment to use realloc()
#endif

/*****************************************************************************
  Default implementation of virtual functions
 *****************************************************************************/

int QGVector::compareItems( Item d1, Item d2 )
{
    return d1 != d2;                            // compare pointers
}

#ifndef QT_NO_DATASTREAM

QDataStream &QGVector::read( QDataStream &s, Item &d )
{                                               // read item from stream
    d = 0;
    return s;
}

QDataStream &QGVector::write( QDataStream &s, Item ) const
{                                               // write item to stream
    return s;
}
#endif // QT_NO_DATASTREAM

/*****************************************************************************
  QGVector member functions
 *****************************************************************************/

QGVector::QGVector()                            // create empty vector
{
    vec = 0;
    len = numItems = 0;
}

QGVector::QGVector( uint size )                 // create vectors with nullptrs
{
    len = size;
    numItems = 0;
    if ( len == 0 ) {                           // zero length
        vec = 0;
        return;
    }
    vec = NEW(Item,len);
    Q_CHECK_PTR( vec );
    memset( (void*)vec, 0, len*sizeof(Item) );  // fill with nulls
}

QGVector::QGVector( const QGVector &a )         // make copy of other vector
    : QPtrCollection( a )
{
    len = a.len;
    numItems = a.numItems;
    if ( len == 0 ) {
        vec = 0;
        return;
    }
    vec = NEW( Item, len );
    Q_CHECK_PTR( vec );
    for ( uint i = 0; i < len; i++ ) {
        if ( a.vec[i] ) {
            vec[i] = newItem( a.vec[i] );
            Q_CHECK_PTR( vec[i] );
        } else {
            vec[i] = 0;
        }
    }
}

QGVector::~QGVector()
{
    clear();
}

QGVector& QGVector::operator=( const QGVector &v )
{
    if ( &v == this )
        return *this;

    clear();
    len = v.len;
    numItems = v.numItems;
    if ( len == 0 ) {
        vec = 0;
        return *this;
    }
    vec = NEW( Item, len );
    Q_CHECK_PTR( vec );
    for ( uint i = 0; i < len; i++ ) {
        if ( v.vec[i] ) {
            vec[i] = newItem( v.vec[i] );
            Q_CHECK_PTR( vec[i] );
        } else {
            vec[i] = 0;
        }
    }
    return *this;
}


bool QGVector::insert( uint index, Item d )     // insert item at index
{
#if defined(QT_CHECK_RANGE)
    if ( index >= len ) {                       // range error
        qWarning( "QGVector::insert: Index %d out of range", index );
        return FALSE;
    }
#endif
    if ( vec[index] ) {                         // remove old item
        deleteItem( vec[index] );
        numItems--;
    }
    if ( d ) {
        vec[index] = newItem( d );
        Q_CHECK_PTR( vec[index] );
        numItems++;
        return vec[index] != 0;
    } else {
        vec[index] = 0;                         // reset item
    }
    return TRUE;
}

bool QGVector::remove( uint index )             // remove item at index
{
#if defined(QT_CHECK_RANGE)
    if ( index >= len ) {                       // range error
        qWarning( "QGVector::remove: Index %d out of range", index );
        return FALSE;
    }
#endif
    if ( vec[index] ) {                         // valid item
        deleteItem( vec[index] );               // delete it
        vec[index] = 0;                         // reset pointer
        numItems--;
    }
    return TRUE;
}

QPtrCollection::Item QGVector::take( uint index )               // take out item
{
#if defined(QT_CHECK_RANGE)
    if ( index >= len ) {                       // range error
        qWarning( "QGVector::take: Index %d out of range", index );
        return 0;
    }
#endif
    Item d = vec[index];                                // don't delete item
    if ( d )
        numItems--;
    vec[index] = 0;
    return d;
}

void QGVector::clear()                          // clear vector
{
    if ( vec ) {
        for ( uint i=0; i<len; i++ ) {          // delete each item
            if ( vec[i] )
                deleteItem( vec[i] );
        }
        DELETE(vec);
        vec = 0;
        len = numItems = 0;
    }
}

bool QGVector::resize( uint newsize )           // resize array
{
    if ( newsize == len )                       // nothing to do
        return TRUE;
    if ( vec ) {                                // existing data
        if ( newsize < len ) {                  // shrink vector
            uint i = newsize;
            while ( i < len ) {                 // delete lost items
                if ( vec[i] ) {
                    deleteItem( vec[i] );
                    numItems--;
                }
                i++;
            }
        }
        if ( newsize == 0 ) {                   // vector becomes empty
            DELETE(vec);
            vec = 0;
            len = numItems = 0;
            return TRUE;
        }
#if defined(DONT_USE_REALLOC)
        if ( newsize == 0 ) {
            DELETE(vec);
            vec = 0;
            return FALSE;
        }
        Item *newvec = NEW(Item,newsize);               // manual realloc
        memcpy( newvec, vec, (len < newsize ? len : newsize)*sizeof(Item) );
        DELETE(vec);
        vec = newvec;
#else
        vec = (Item*)realloc( (char *)vec, newsize*sizeof(Item) );
#endif
    } else {                                    // create new vector
        vec = NEW(Item,newsize);
        len = numItems = 0;
    }
    Q_CHECK_PTR( vec );
    if ( !vec )                                 // no memory
        return FALSE;
    if ( newsize > len )                        // init extra space added
        memset( (void*)&vec[len], 0, (newsize-len)*sizeof(Item) );
    len = newsize;
    return TRUE;
}


bool QGVector::fill( Item d, int flen )         // resize and fill vector
{
    if ( flen < 0 )
        flen = len;                             // default: use vector length
    else if ( !resize( flen ) )
        return FALSE;
    for ( uint i=0; i<(uint)flen; i++ )         // insert d at every index
        insert( i, d );
    return TRUE;
}


static QGVector *sort_vec=0;                    // current sort vector


#if defined(Q_C_CALLBACKS)
extern "C" {
#endif

#ifdef Q_OS_TEMP
static int _cdecl cmp_vec( const void *n1, const void *n2 )
#else
static int cmp_vec( const void *n1, const void *n2 )
#endif
{
    return sort_vec->compareItems( *((QPtrCollection::Item*)n1), *((QPtrCollection::Item*)n2) );
}

#if defined(Q_C_CALLBACKS)
}
#endif


void QGVector::sort()                           // sort vector
{
    if ( count() == 0 )                         // no elements
        return;
    register Item *start = &vec[0];
    register Item *end  = &vec[len-1];
    Item tmp;
    for (;;) {                          // put all zero elements behind
        while ( start < end && *start != 0 )
            start++;
        while ( end > start && *end == 0 )
            end--;
        if ( start < end ) {
            tmp = *start;
            *start = *end;
            *end = tmp;
        } else {
            break;
        }
    }

#ifdef QT_THREAD_SUPPORT
    QMutexLocker locker( qt_global_mutexpool ?
                         qt_global_mutexpool->get( &sort_vec ) : 0 );
#endif // QT_THREAD_SUPPORT

    sort_vec = (QGVector*)this;
    qsort( vec, count(), sizeof(Item), cmp_vec );
    sort_vec = 0;
}

int QGVector::bsearch( Item d ) const           // binary search; when sorted
{
    if ( !len )
        return -1;
    if ( !d ) {
#if defined(QT_CHECK_NULL)
        qWarning( "QGVector::bsearch: Cannot search for null object" );
#endif
        return -1;
    }
    int n1 = 0;
    int n2 = len - 1;
    int mid = 0;
    bool found = FALSE;
    while ( n1 <= n2 ) {
        int  res;
        mid = (n1 + n2)/2;
        if ( vec[mid] == 0 )                    // null item greater
            res = -1;
        else
            res = ((QGVector*)this)->compareItems( d, vec[mid] );
        if ( res < 0 )
            n2 = mid - 1;
        else if ( res > 0 )
            n1 = mid + 1;
        else {                                  // found it
            found = TRUE;
            break;
        }
    }
    if ( !found )
        return -1;
    // search to first of equal items
    while ( (mid - 1 >= 0) && !((QGVector*)this)->compareItems(d, vec[mid-1]) )
        mid--;
    return mid;
}

int QGVector::findRef( Item d, uint index) const // find exact item in vector
{
#if defined(QT_CHECK_RANGE)
    if ( index > len ) {                        // range error
        qWarning( "QGVector::findRef: Index %d out of range", index );
        return -1;
    }
#endif
    for ( uint i=index; i<len; i++ ) {
        if ( vec[i] == d )
            return i;
    }
    return -1;
}

int QGVector::find( Item d, uint index ) const  // find equal item in vector
{
#if defined(QT_CHECK_RANGE)
    if ( index >= len ) {                       // range error
        qWarning( "QGVector::find: Index %d out of range", index );
        return -1;
    }
#endif
    for ( uint i=index; i<len; i++ ) {
        if ( vec[i] == 0 && d == 0 )            // found null item
            return i;
        if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
            return i;
    }
    return -1;
}

uint QGVector::containsRef( Item d ) const      // get number of exact matches
{
    uint count = 0;
    for ( uint i=0; i<len; i++ ) {
        if ( vec[i] == d )
            count++;
    }
    return count;
}

uint QGVector::contains( Item d ) const         // get number of equal matches
{
    uint count = 0;
    for ( uint i=0; i<len; i++ ) {
        if ( vec[i] == 0 && d == 0 )            // count null items
            count++;
        if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
            count++;
    }
    return count;
}

bool QGVector::insertExpand( uint index, Item d )// insert and grow if necessary
{
    if ( index >= len ) {
        if ( !resize( index+1 ) )               // no memory
            return FALSE;
    }
    insert( index, d );
    return TRUE;
}

void QGVector::toList( QGList *list ) const     // store items in list
{
    list->clear();
    for ( uint i=0; i<len; i++ ) {
        if ( vec[i] )
            list->append( vec[i] );
    }
}


void QGVector::warningIndexRange( uint i )
{
#if defined(QT_CHECK_RANGE)
    qWarning( "QGVector::operator[]: Index %d out of range", i );
#else
    Q_UNUSED( i )
#endif
}


/*****************************************************************************
  QGVector stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator>>( QDataStream &s, QGVector &vec )
{                                               // read vector
    return vec.read( s );
}

QDataStream &operator<<( QDataStream &s, const QGVector &vec )
{                                               // write vector
    return vec.write( s );
}

QDataStream &QGVector::read( QDataStream &s )   // read vector from stream
{
    uint num;
    s >> num;                                   // read number of items
    clear();                                    // clear vector
    resize( num );
    for (uint i=0; i<num; i++) {                // read all items
        Item d;
        read( s, d );
        Q_CHECK_PTR( d );
        if ( !d )                               // no memory
            break;
        vec[i] = d;
    }
    return s;
}

QDataStream &QGVector::write( QDataStream &s ) const
{                                               // write vector to stream
    uint num = count();
    s << num;                                   // number of items to write
    num = size();
    for (uint i=0; i<num; i++) {                // write non-null items
        if ( vec[i] )
            write( s, vec[i] );
    }
    return s;
}

/* Returns whether v equals this vector or not */

bool QGVector::operator==( const QGVector &v ) const
{
    if ( size() != v.size() )
        return FALSE;
    if ( count() != v.count() )
        return FALSE;
    for ( int i = 0; i < (int)size(); ++i ) {
        if ( ( (QGVector*)this )->compareItems( at( i ), v.at( i ) ) != 0 )
            return FALSE;
    }
    return TRUE;
}

#endif // QT_NO_DATASTREAM

---