Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.trolltech.qt.core
Class QBitArray

    java.lang.Object
      com.trolltech.qt.QSignalEmitter
          com.trolltech.qt.QtJambiObject
              com.trolltech.qt.core.QBitArray

All Implemented Interfaces:
  QtJambiInterface

    public class QBitArray

extends QtJambiObject

The `QBitArray` class provides an array of bits.

A `QBitArray` is an array that gives access to individual bits and provides operators (AND, OR, XOR, and NOT) that work on entire arrays of bits. It uses implicit sharing (copy-on-write) to reduce memory usage and to avoid the needless copying of data.

The following code constructs a `QBitArray` containing 200 bits initialized to false (0):

        QBitArray ba(200);

To initialize the bits to true, either pass `true` as second argument to the constructor, or call `fill` later on.

`QBitArray` uses 0-based indexes, just like C++ arrays. To access the bit at a particular index position, you can use operator[](). On non-const bit arrays, operator[]() returns a reference to a bit that can be used on the left side of an assignment. For example:

        QBitArray ba;
        ba.resize(3);
        ba[0] = true;
        ba[1] = false;
        ba[2] = true;

For technical reasons, it is more efficient to use `testBit` and `setBit` to access bits in the array than operator[](). For example:

        QBitArray ba(3);
        ba.setBit(0, true);
        ba.setBit(1, false);
        ba.setBit(2, true);

`QBitArray` supports `&` (AND), `|` (OR), `^` (XOR), `~` (NOT), as well as `&=`, `|=`, and `^=`. These operators work in the same way as the built-in C++ bitwise operators of the same name. For example:

        QBitArray x(5);
        x.setBit(3, true);
        // x: [ 0, 0, 0, 1, 0 ]

        QBitArray y(5);
        y.setBit(4, true);
        // y: [ 0, 0, 0, 0, 1 ]

        x |= y;
        // x: [ 0, 0, 0, 1, 1 ]

For historical reasons, `QBitArray` distinguishes between a null bit array and an empty bit array. A null bit array is a bit array that is initialized using `QBitArray`'s default constructor. An empty bit array is any bit array with size 0. A null bit array is always empty, but an empty bit array isn't necessarily null:

        QBitArray().isNull();           // returns true
        QBitArray().isEmpty();          // returns true

        QBitArray(0).isNull();          // returns false
        QBitArray(0).isEmpty();         // returns true

        QBitArray(3).isNull();          // returns false
        QBitArray(3).isEmpty();         // returns false

All functions except `isNull` treat null bit arrays the same as empty bit arrays; for example, `QBitArray` compares equal to `QBitArray`(0). We recommend that you always use `isEmpty` and avoid `isNull`.

See Also:
  `QByteArray`, `QVector`

Nested Class Summary

Nested classes/interfaces inherited from class com.trolltech.qt.QSignalEmitter
`QSignalEmitter.AbstractSignal, QSignalEmitter.Signal0, QSignalEmitter.Signal1<A>, QSignalEmitter.Signal2<A,B>, QSignalEmitter.Signal3<A,B,C>, QSignalEmitter.Signal4<A,B,C,D>, QSignalEmitter.Signal5<A,B,C,D,E>, QSignalEmitter.Signal6<A,B,C,D,E,F>, QSignalEmitter.Signal7<A,B,C,D,E,F,G>, QSignalEmitter.Signal8<A,B,C,D,E,F,G,H>, QSignalEmitter.Signal9<A,B,C,D,E,F,G,H,I>`

Constructor Summary
`QBitArray()` Constructs an empty bit array.
`QBitArray(int size)` Equivalent to `QBitArray`(`size`, false).
`QBitArray(int size, boolean val)` Constructs a bit array containing `size` bits.
`QBitArray(QBitArray other)` Constructs a copy of `other`.

Method Summary
`void` | `and(QBitArray other)` Returns a bit array that is the AND of this bit array and `other`.
`boolean` | `at(int i)` Returns the value of the bit at index position `i`.
`void` | `clear()` Clears the contents of the bit array and makes it empty.
`void` | `clearBit(int i)` Sets the bit at index position `i` to 0.
`int` | `count()` Same as `size`.
`int` | `count(boolean on)` If `on` is true, this function returns the number of 1-bits stored in the bit array; otherwise the number of 0-bits is returned.
`boolean` | `equals(java.lang.Object other)`
`boolean` | `fill(boolean val)` Equivalent to fill(`val`, -1).
`boolean` | `fill(boolean val, int size)` Sets every bit in the bit array to `val`, returning true if successful; otherwise returns false.
`void` | `fill(boolean val, int first, int last)` Sets bits at index positions `first` up to and excluding `last` to `val`.
`static QBitArray` | `fromNativePointer(QNativePointer nativePointer)` This function returns the QBitArray instance pointed to by nativePointer
`int` | `hashCode()`
`QBitArray` | `inverted()` Returns a bit array that contains the inverted bits of this bit array.
`boolean` | `isEmpty()` Returns true if this bit array has size 0; otherwise returns false.
`boolean` | `isNull()` Returns true if this bit array is null; otherwise returns false.
`static QNativePointer` | `nativePointerArray(QBitArray[] array)` This function returns a QNativePointer that is pointing to the specified QBitArray array.
`void` | `or(QBitArray other)` Returns a bit array that is the OR of this bit array and `other`.
`void` | `readFrom(QDataStream arg__1)` Reads a QBitArray from arg__1.
`void` | `resize(int size)` Resizes the bit array to `size` bits.
`void` | `set(QBitArray other)` This function sets the contents of this array to the same as `other`s.
`void` | `setBit(int i)` Sets the bit at index position `i` to 1.
`void` | `setBit(int i, boolean val)` Sets the bit at index position `i` to `val`.
`int` | `size()` Returns the number of bits stored in the bit array.
`boolean` | `testBit(int i)` Returns true if the bit at index position `i` is 1; otherwise returns false.
`boolean` | `toggleBit(int i)` Inverts the value of the bit at index position `i`, returning the previous value of that bit as either true (if it was set) or false (if it was unset).
`void` | `truncate(int pos)` Truncates the bit array at index position `pos`.
`void` | `writeTo(QDataStream arg__1)` Writes thisQBitArray to arg__1.
`void` | `xor(QBitArray other)` Returns a bit array that is the XOR of this bit array and `other`.

Methods inherited from class com.trolltech.qt.QtJambiObject
`dispose, disposed, finalize, reassignNativeResources, tr, tr, tr`

Methods inherited from class com.trolltech.qt.QSignalEmitter
`blockSignals, disconnect, disconnect, signalsBlocked, signalSender, thread`

Methods inherited from class java.lang.Object
`clone, getClass, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface com.trolltech.qt.QtJambiInterface
`disableGarbageCollection, nativeId, nativePointer, reenableGarbageCollection, setJavaOwnership`

Constructor Detail

### QBitArray

    public QBitArray(int size)

  Equivalent to `QBitArray`(`size`, false).

### QBitArray

    public QBitArray(int size,
                     boolean val)

  Constructs a bit array containing `size` bits. The bits are initialized with `val`, which defaults to false (0).

### QBitArray

    public QBitArray(QBitArray other)

  Constructs a copy of `other`.

  This operation takes constant time, because `QBitArray` is implicitly shared. This makes returning a `QBitArray` from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes linear time.

  See Also:
    `operator=`

### QBitArray

    public QBitArray()

  Constructs an empty bit array.

  See Also:
    `isEmpty`

Method Detail

### at

    public final boolean at(int i)

  Returns the value of the bit at index position `i`.

  `i` must be a valid index position in the bit array (i.e., 0 <= `i` < `size`).

  See Also:
    `operator[]`

### clear

    public final void clear()

  Clears the contents of the bit array and makes it empty.

  See Also:
    `resize`, `isEmpty`

### clearBit

    public final void clearBit(int i)

  Sets the bit at index position `i` to 0.

  `i` must be a valid index position in the bit array (i.e., 0 <= `i` < `size`).

  See Also:
    `setBit`, `toggleBit`

### count

    public final int count(boolean on)

  If `on` is true, this function returns the number of 1-bits stored in the bit array; otherwise the number of 0-bits is returned.

### count

    public final int count()

  Same as `size`.

### fill

    public final void fill(boolean val,
                           int first,
                           int last)

  Sets bits at index positions `first` up to and excluding `last` to `val`.

  `first` and `last` must be a valid index position in the bit array (i.e., 0 <= `first` <= `size` and 0 <= `last` <= `size`).

### fill

    public final boolean fill(boolean val)

  Equivalent to fill(`val`, -1).

### fill

    public final boolean fill(boolean val,
                              int size)

  Sets every bit in the bit array to `val`, returning true if successful; otherwise returns false. If `size` is different from -1 (the default), the bit array is resized to `size` beforehand.

  Example:

          QBitArray ba(8);
          ba.fill(true);
          // ba: [ 1, 1, 1, 1, 1, 1, 1, 1 ]

          ba.fill(false, 2);
          // ba: [ 0, 0 ]

  See Also:
    `resize`

### isEmpty

    public final boolean isEmpty()

  Returns true if this bit array has size 0; otherwise returns false.

  See Also:
    `size`

### isNull

    public final boolean isNull()

  Returns true if this bit array is null; otherwise returns false.

  Example:

          QBitArray().isNull();           // returns true
          QBitArray(0).isNull();          // returns false
          QBitArray(3).isNull();          // returns false

  Qt makes a distinction between null bit arrays and empty bit arrays for historical reasons. For most applications, what matters is whether or not a bit array contains any data, and this can be determined using `isEmpty`.

  See Also:
    `isEmpty`

### writeTo

    public final void writeTo(QDataStream arg__1)

  Writes thisQBitArray to arg__1.

### readFrom

    public final void readFrom(QDataStream arg__1)

  Reads a QBitArray from arg__1.

### resize

    public final void resize(int size)

  Resizes the bit array to `size` bits.

  If `size` is greater than the current size, the bit array is extended to make it `size` bits with the extra bits added to the end. The new bits are initialized to false (0).

  If `size` is less than the current size, bits are removed from the end.

  See Also:
    `size`

### setBit

    public final void setBit(int i)

  Sets the bit at index position `i` to 1.

  `i` must be a valid index position in the bit array (i.e., 0 <= `i` < `size`).

  See Also:
    `clearBit`, `toggleBit`

### setBit

    public final void setBit(int i,
                             boolean val)

  Sets the bit at index position `i` to `val`.

### size

    public final int size()

  Returns the number of bits stored in the bit array.

  See Also:
    `resize`

### testBit

    public final boolean testBit(int i)

  Returns true if the bit at index position `i` is 1; otherwise returns false.

  `i` must be a valid index position in the bit array (i.e., 0 <= `i` < `size`).

  See Also:
    `setBit`, `clearBit`

### toggleBit

    public final boolean toggleBit(int i)

  Inverts the value of the bit at index position `i`, returning the previous value of that bit as either true (if it was set) or false (if it was unset).

  If the previous value was 0, the new value will be 1. If the previous value was 1, the new value will be 0.

  `i` must be a valid index position in the bit array (i.e., 0 <= `i` < `size`).

  See Also:
    `setBit`, `clearBit`

### truncate

    public final void truncate(int pos)

  Truncates the bit array at index position `pos`.

  If `pos` is beyond the end of the array, nothing happens.

  See Also:
    `resize`

### fromNativePointer

    public static QBitArray fromNativePointer(QNativePointer nativePointer)

  This function returns the QBitArray instance pointed to by nativePointer

  Parameters:
    `nativePointer` - the QNativePointer of which object should be returned.

### nativePointerArray

    public static QNativePointer nativePointerArray(QBitArray[] array)

  This function returns a QNativePointer that is pointing to the specified QBitArray array.

  Parameters:
    `array` - the array that the returned pointer will point to.
  Returns:
    a QNativePointer that is pointing to the specified array.

### equals

    public boolean equals(java.lang.Object other)

  Overrides:
    `equals` in class `java.lang.Object`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `java.lang.Object`

### xor

    public void xor(QBitArray other)

  Returns a bit array that is the XOR of this bit array and `other`.

  The result has the length of the longest of the two bit arrays, with any missing bits (if one array is shorter than the other) taken to be 0.

  Example:

  ``

          QBitArray a(3);
          QBitArray b(2);
          QBitArray c;
          a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
          b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
          c = a ^ b;                      // c: [ 0, 1, 1 ]

### and

    public void and(QBitArray other)

  Returns a bit array that is the AND of this bit array and `other`.

  The result has the length of the longest of the two bit arrays, with any missing bits (if one array is shorter than the other) taken to be 0.

  Example:

  ``

          QBitArray a(3);
          QBitArray b(2);
          QBitArray c;
          a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
          b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
          c = a & b;                      // c: [ 1, 0, 0 ]

### or

    public void or(QBitArray other)

  Returns a bit array that is the OR of this bit array and `other`.

  The result has the length of the longest of the two bit arrays, with any missing bits (if one array is shorter than the other) taken to be 0.

  Example:

  ``

          QBitArray a(3);
          QBitArray b(2);
          QBitArray c;
          a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
          b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
          c = a | b;                      // c: [ 1, 1, 1 ]

### set

    public void set(QBitArray other)

  This function sets the contents of this array to the same as `other`s.

### inverted

    public QBitArray inverted()

  Returns a bit array that contains the inverted bits of this bit array.

  Example:

  ``

          QBitArray a(3);
          QBitArray b;
          a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
          b = ~a;                         // b: [ 0, 1, 0 ]

Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD