Class cBitArray

avida-core/source/tools/cBitArray.h:236–447

};

class cBitArray {
private:
  cRawBitArray bit_array;
  int array_size;

  // Setup a bit proxy so that we can use operator[] on bit arrays as a lvalue.
  class cBitProxy {
  private:
    cBitArray & array;
    int index;
  public:
    cBitProxy(cBitArray & _array, int _idx) : array(_array), index(_idx) {;}

    inline cBitProxy & operator=(bool b);    // lvalue handling...
    inline operator bool() const;            // rvalue handling...
  };
  friend class cBitProxy;
public:
  cBitArray() : array_size(0) { ; }
  cBitArray(int in_size) : bit_array(in_size), array_size(in_size) { ; }
  cBitArray(const cBitArray & in_array)
    : bit_array(in_array.bit_array, in_array.array_size)
    , array_size(in_array.array_size) { ; }
  cBitArray(const cRawBitArray & in_array, int in_size)
    : bit_array(in_array, in_size)
    , array_size(in_size) { ; }

  cBitArray & operator=(const cBitArray & in_array) {
    bit_array.Copy(in_array.bit_array, in_array.array_size);
    array_size = in_array.array_size;
    return *this;
  }

  bool operator==(const cBitArray & in_array) const {
    if (array_size != in_array.array_size) return false;
    return bit_array.IsEqual(in_array.bit_array, array_size);
  }

  int GetSize() const { return array_size; }

  void Set(int index, bool value) {
    assert(index < array_size);
    bit_array.SetBit(index, value);
  }

  bool Get(int index) const {
    assert(index < array_size);
    return bit_array.GetBit(index);
  }

  bool operator[](int index) const { return Get(index); }
  cBitProxy operator[](int index) { return cBitProxy(*this, index); }

  void Clear() { bit_array.Zero(array_size); }
  void SetAll() { bit_array.Ones(array_size); }
  

  void Print(ostream & out=cout) const { bit_array.Print(array_size, out); }