bitArray.H

/*
  This file is part of Aleph system

  Copyright (c) 2002, 2003, 2004, 2005, 2006
  UNIVERSITY LOS ANDES (ULA) Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA  

  - Center of Studies in Microelectronics & Distributed Systems (CEMISID) 
  - ULA Computer Science Department
  - FUNDACITE Mérida - Ministerio de Ciencia y Tecnología

  PERMISSION TO USE, COPY, MODIFY AND DISTRIBUTE THIS SOFTWARE AND ITS
  DOCUMENTATION IS HEREBY GRANTED, PROVIDED THAT BOTH THE COPYRIGHT
  NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES OF THE
  SOFTWARE, DERIVATIVE WORKS OR MODIFIED VERSIONS, AND ANY PORTIONS
  THEREOF, AND THAT BOTH NOTICES APPEAR IN SUPPORTING DOCUMENTATION.

  Aleph is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE.

  UNIVERSIDAD DE LOS ANDES requests users of this software to return to 

  Leandro Leon
  CEMISID 
  Ed La Hechicera 
  3er piso, ala sur
  Facultad de Ingenieria 
  Universidad de Los Andes 
  Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA    or

  lrleon@ula.ve

  any improvements or extensions that they make and grant Universidad 
  de Los Andes (ULA) the rights to redistribute these changes. 

  Aleph is (or was) granted by: 
  - Consejo de Desarrollo Cientifico, Humanistico, Tecnico de la ULA 
    (CDCHT)
  - Fundacite Mérida
*/


# ifndef BITARRAY_H
# define BITARRAY_H

# include <aleph.H>

namespace Aleph {

class BitArray
{

private:

  struct Byte
  {
    unsigned int b0 : 1;
    unsigned int b1 : 1;
    unsigned int b2 : 1;
    unsigned int b3 : 1;
    unsigned int b4 : 1;
    unsigned int b5 : 1;
    unsigned int b6 : 1;
    unsigned int b7 : 1;

    unsigned int read_bit(const unsigned int & i) const
    {

      I(i < 8);

      switch (i)
        {
        case 0 : return b0;
        case 1 : return b1;
          // ...

        case 2 : return b2;
        case 3 : return b3;
        case 4 : return b4;
        case 5 : return b5;
        case 6 : return b6;

        case 7 : return b7;

        default: throw std::out_of_range ("bit index greater than 7"); 

        }
    } 
    void write_bit(const unsigned int & i, const unsigned int & value)
    {

      I(i < 8);
      I(value <= 1);

      switch (i)
        {
        case 0 : b0 = value; break;
        case 1 : b1 = value; break;
          // ...

        case 2 : b2 = value; break;
        case 3 : b3 = value; break;
        case 4 : b4 = value; break;
        case 5 : b5 = value; break;
        case 6 : b6 = value; break;

        case 7 : b7 = value; break;

        default: throw std::out_of_range ("bit index greater than 7"); 

        }
    } 
    Byte() : b0(0), b1(0), b2(0), b3(0), b4(0), b5(0), b6(0), b7(0) { /* empty */ }
  };
  mutable size_t     num_bits;
  mutable size_t     num_bytes; 
  Byte * array_of_bytes; 
  class BitProxy
  {
    const size_t bit_index;
    Byte * byte_ptr;

  public:

    BitProxy(BitArray & array, const size_t & i) : bit_index(i % 8)
    {

      if (i >= array.num_bits)
        throw std::out_of_range ("Bit array size too big");

      const size_t byte_index = i/8;

      byte_ptr = &array.array_of_bytes[byte_index];
    }
    operator int () const { return byte_ptr->read_bit(bit_index); }
    BitProxy& operator = (const size_t & value)
    {

      I(value <= 1);

      byte_ptr->write_bit(bit_index, value);

      return *this;
    }
    BitProxy& operator = (const BitProxy & proxy)
    {
      byte_ptr->write_bit(bit_index, proxy.byte_ptr->read_bit(proxy.bit_index));

      return *this;
    }
  };

public:

  BitArray(const size_t & dim = 256) 

    throw(std::exception, std::bad_alloc) 

    : num_bits(dim), num_bytes(num_bits/8 + (((num_bits % 8) != 0) ? 1 : 0)), 
      array_of_bytes (new Byte [num_bytes]) 
  {
    // empty
  }

  ~BitArray() { delete [] array_of_bytes; }

  const size_t & get_len() const { return num_bits; }

  const size_t & size() const { return  get_len(); }
  BitProxy operator [] (const size_t & i) const
  { 
    return BitProxy(const_cast<BitArray&>(*this), i);
  }

  BitProxy operator [] (const size_t & i)
  { 
    return BitProxy(*this, i);
  }
  int read_bit(const size_t & i) const
  {
    const int bit_index = i % 8;

    return array_of_bytes[i/8].read_bit(bit_index);
  }

  void write_bit(const size_t & i, const unsigned int & value) const
  {
    array_of_bytes[i/8].write_bit(i, value);
  }
  BitArray(const BitArray & array) 
    throw(std::exception, std::bad_alloc)
    :  num_bits(array.num_bits), num_bytes(array.num_bytes),
       array_of_bytes (new Byte [num_bytes])
  { 
    for (int i = 0; i < num_bytes; ++i)
      array_of_bytes[i] = array.array_of_bytes[i];
  }

  BitArray(const BitArray & array, const size_t & dim) 
    throw(std::exception, std::bad_alloc)
    : num_bits       (dim),         
      num_bytes      (num_bits/8 + (((num_bits % 8) != 0) ? 1 : 0)),
      array_of_bytes (new Byte [num_bytes])
  { 
        // copiar contenido de array
    const size_t n = Aleph::min(num_bytes, array.num_bytes);

    for (int i = 0; i < n; ++i)
      array_of_bytes[i] = array.array_of_bytes[i];
  }

  BitArray & operator = (const BitArray & array) 
    throw(std::exception, std::bad_alloc)
  {
    if (this == &array)
      return *this;
    
        // respaldar atributos por si ocurre excepción
    Byte * old_array = array_of_bytes; 
    const size_t old_num_bits  = num_bits;
    const size_t old_num_bytes = num_bytes;

    num_bits  = array.num_bits;
    num_bytes = array.num_bytes; 

    try
      {
        array_of_bytes = new Byte [num_bytes];

        delete [] old_array;

        for (int i = 0; i < num_bytes; ++i)
          array_of_bytes[i] = array.array_of_bytes[i];

        return *this;
      }
    catch (std::bad_alloc) 
      {
        num_bits  = old_num_bits;
        num_bytes = old_num_bytes;
        array_of_bytes = old_array;

        throw;
      }
  }
  void resize(const size_t & new_dim) 

    throw(std::exception, std::bad_alloc)

  {
    const size_t new_num_bytes = new_dim/8 + (((new_dim % 8) != 0) ? 1 : 0);
    
    Byte * new_array_of_bytes = new Byte [new_num_bytes];

    for (int i = 0; i < new_num_bytes; ++i)
      new_array_of_bytes[i] = array_of_bytes[i];

    num_bits  = new_dim;
    num_bytes = new_num_bytes;

    delete [] array_of_bytes;

    array_of_bytes = new_array_of_bytes;
  }
};

} // end namespace Aleph
# endif /* BITARRAY_H */

---