qbitarray.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qbitarray.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of QBitArray class
**
** Created : 940118
**
** 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 "qbitarray.h"
#include "qdatastream.h"

#define SHBLOCK  ((bitarr_data*)(sharedBlock()))


QBitArray::QBitArray() : QByteArray( 0, 0 )
{
    bitarr_data *x = new bitarr_data;
    Q_CHECK_PTR( x );
    x->nbits = 0;
    setSharedBlock( x );
}

QBitArray::QBitArray( uint size ) : QByteArray( 0, 0 )
{
    bitarr_data *x = new bitarr_data;
    Q_CHECK_PTR( x );
    x->nbits = 0;
    setSharedBlock( x );
    resize( size );
}

void QBitArray::pad0()
{
    uint sz = size();
    if ( sz && sz%8 )
        *(data()+sz/8) &= (1 << (sz%8)) - 1;
}


bool QBitArray::resize( uint size )
{
    uint s = this->size();
    if ( !QByteArray::resize( (size+7)/8 ) )
        return FALSE;                           // cannot resize
    SHBLOCK->nbits = size;
    if ( size != 0 ) {                          // not null array
        int ds = (int)(size+7)/8 - (int)(s+7)/8;// number of bytes difference
        if ( ds > 0 )                           // expanding array
            memset( data() + (s+7)/8, 0, ds );  //   reset new data
    }
    return TRUE;
}


bool QBitArray::fill( bool v, int size )
{
    if ( size >= 0 ) {                          // resize first
        if ( !resize( size ) )
            return FALSE;                       // cannot resize
    } else {
        size = this->size();
    }
    if ( size > 0 )
        memset( data(), v ? 0xff : 0, (size + 7) / 8 );
    if ( v )
        pad0();
    return TRUE;
}


void QBitArray::detach()
{
    int nbits = SHBLOCK->nbits;
    this->duplicate( *this );
    SHBLOCK->nbits = nbits;
}

QBitArray QBitArray::copy() const
{
    QBitArray tmp;
    tmp.duplicate( *this );
    ((bitarr_data*)(tmp.sharedBlock()))->nbits = SHBLOCK->nbits;
    return tmp;
}


bool QBitArray::testBit( uint index ) const
{
#if defined(QT_CHECK_RANGE)
    if ( index >= size() ) {
        qWarning( "QBitArray::testBit: Index %d out of range", index );
        return FALSE;
    }
#endif
    return (*(data()+(index>>3)) & (1 << (index & 7))) != 0;
}

void QBitArray::setBit( uint index )
{
#if defined(QT_CHECK_RANGE)
    if ( index >= size() ) {
        qWarning( "QBitArray::setBit: Index %d out of range", index );
        return;
    }
#endif
    *(data()+(index>>3)) |= (1 << (index & 7));
}

void QBitArray::clearBit( uint index )
{
#if defined(QT_CHECK_RANGE)
    if ( index >= size() ) {
        qWarning( "QBitArray::clearBit: Index %d out of range", index );
        return;
    }
#endif
    *(data()+(index>>3)) &= ~(1 << (index & 7));
}

bool QBitArray::toggleBit( uint index )
{
#if defined(QT_CHECK_RANGE)
    if ( index >= size() ) {
        qWarning( "QBitArray::toggleBit: Index %d out of range", index );
        return FALSE;
    }
#endif
    register uchar *p = (uchar *)data() + (index>>3);
    uchar b = (1 << (index & 7));               // bit position
    uchar c = *p & b;                           // read bit
    *p ^= b;                                    // toggle bit
    return c;
}


QBitArray &QBitArray::operator&=( const QBitArray &a )
{
    resize( QMAX(size(), a.size()) );
    register uchar *a1 = (uchar *)data();
    register uchar *a2 = (uchar *)a.data();
    int n = QMIN( QByteArray::size(), a.QByteArray::size() );
    int p = QMAX( QByteArray::size(), a.QByteArray::size() ) - n;
    while ( n-- > 0 )
        *a1++ &= *a2++;
    while ( p-- > 0 )
        *a1++ = 0;
    return *this;
}

QBitArray &QBitArray::operator|=( const QBitArray &a )
{
    resize( QMAX(size(), a.size()) );
    register uchar *a1 = (uchar *)data();
    register uchar *a2 = (uchar *)a.data();
    int n = QMIN( QByteArray::size(), a.QByteArray::size() );
    while ( n-- > 0 )
        *a1++ |= *a2++;
    return *this;
}

QBitArray &QBitArray::operator^=( const QBitArray &a )
{
    resize( QMAX(size(), a.size()) );
    register uchar *a1 = (uchar *)data();
    register uchar *a2 = (uchar *)a.data();
    int n = QMIN( QByteArray::size(), a.QByteArray::size() );
    while ( n-- > 0 )
        *a1++ ^= *a2++;
    return *this;
}

QBitArray QBitArray::operator~() const
{
    QBitArray a( size() );
    register uchar *a1 = (uchar *)data();
    register uchar *a2 = (uchar *)a.data();
    int n = QByteArray::size();
    while ( n-- )
        *a2++ = ~*a1++;
    a.pad0();
    return a;
}


QBitArray operator&( const QBitArray &a1, const QBitArray &a2 )
{
    QBitArray tmp = a1.copy();
    tmp &= a2;
    return tmp;
}

QBitArray operator|( const QBitArray &a1, const QBitArray &a2 )
{
    QBitArray tmp = a1.copy();
    tmp |= a2;
    return tmp;
}

QBitArray operator^( const QBitArray &a1, const QBitArray &a2 )
{
    QBitArray tmp = a1.copy();
    tmp ^= a2;
    return tmp;
}


/* \enum QGArray::array_data

  \warning This will be renamed in the next major release of Qt.  Until
  then it is undocumented and we recommend against its use.

  \internal

  ### 3.0 rename ###
  ### 3.0 move it to QGArray? ###
*/


/*****************************************************************************
  QBitArray stream functions
 *****************************************************************************/

#ifndef QT_NO_DATASTREAM
QDataStream &operator<<( QDataStream &s, const QBitArray &a )
{
    Q_UINT32 len = a.size();
    s << len;                                   // write size of array
    if ( len > 0 )                              // write data
        s.writeRawBytes( a.data(), a.QByteArray::size() );
    return s;
}

QDataStream &operator>>( QDataStream &s, QBitArray &a )
{
    Q_UINT32 len;
    s >> len;                                   // read size of array
    if ( !a.resize( (uint)len ) ) {             // resize array
#if defined(QT_CHECK_NULL)
        qWarning( "QDataStream: Not enough memory to read QBitArray" );
#endif
        len = 0;
    }
    if ( len > 0 )                              // read data
        s.readRawBytes( a.data(), a.QByteArray::size() );
    return s;
}

#endif // QT_NO_DATASTREAM

---