bitVector.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: bitVector.h,v 1.47 2005/12/23 17:01:41 amoll Exp $
//

#ifndef BALL_DATATYPE_BITVECTOR_H
#define BALL_DATATYPE_BITVECTOR_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_CONCEPT_PERSISTENCEMANAGER_H
# include <BALL/CONCEPT/persistenceManager.h>
#endif

#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif


#include <string.h>

#define BALL_BLOCK_BITS 8
#define BALL_BLOCK_MASK (BALL_BLOCK_BITS - 1)
#define BALL_BLOCK_SHIFT              3
#define BALL_BLOCK_ALL_BITS_SET       0xFF
#define BALL_BLOCK_ALL_BITS_CLEARED   0x00


#define BALL_BLOCK_SIZE(bits) (Size)(((bits) + BALL_BLOCK_BITS - 1) >> BALL_BLOCK_SHIFT)


namespace BALL 
{
  class BitVector;

  class BALL_EXPORT Bit
  {
    public:


    class BALL_EXPORT IllegalOperation
      : public Exception::GeneralException
    {
      public:
      IllegalOperation(const char* file, int line);
    };




    BALL_CREATE(Bit)

    
    Bit();

    Bit(const Bit& bit);

    Bit(BitVector* bitvector, Index index = 0) 
      throw(Exception::NullPointer);

    Bit(const BitVector* const bitvector, Index index = 0) 
      throw(Exception::NullPointer, Exception::IndexUnderflow, Exception::IndexOverflow);

    virtual ~Bit();


    
    operator bool() const throw(Exception::NullPointer);


    
    Bit& operator = (const Bit& bit);

    Bit& operator = (const bool bit) 
      throw(Exception::NullPointer, IllegalOperation);

    virtual void clear();



    bool operator == (const Bit& bit) const;

    bool operator == (bool bit) const throw(Exception::NullPointer);

    bool operator != (const Bit& bit) const;

    bool operator != (bool bit) const throw(Exception::NullPointer);


    private:

    // --- ATTRIBUTES

    BitVector*  bitvector_;
    Index       index_;
    bool        bitvector_muteable_;
  };


  class BALL_EXPORT BitVector
  {
    public:

    BALL_CREATE(BitVector)


    

    typedef unsigned char BlockType;
    typedef std::vector<BlockType>  VectorType;
    static const Size BlockSize;



    BitVector();

    BitVector(Size size) throw(Exception::OutOfMemory);

    BitVector(const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector(const char* bit_string)
     throw(Exception::OutOfMemory);

    virtual ~BitVector();

    void clear();



    void set(const BitVector& bit_vector)
      throw(Exception::OutOfMemory);

    void set(const char* bit_string)
      throw(Exception::OutOfMemory);

    BitVector& operator = (const BitVector& bit_vector)
      throw(Exception::OutOfMemory);

    BitVector& operator = (const char *bit_string)
      throw(Exception::OutOfMemory);

    void get(BitVector& bitvector) const
      throw(Exception::OutOfMemory);


    BitVector operator () (Index first,Index last) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    void setSize(Size size, bool keep = true)
      throw(Exception::OutOfMemory);

    Size getSize() const;

    Size countValue(bool value) const;

    VectorType& getBitSet();

    const VectorType& getBitSet() const;

    Bit operator [] (Index index)
      throw(Exception::OutOfMemory);

    bool operator [] (Index index) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    void setBit(Index index, bool value = true)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    bool getBit(Index index)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    bool getBit(Index index) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    void toggleBit(Index index)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    void fill(bool value = true, Index first = 0 , Index last = -1)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    void toggle(Index first = 0, Index last = -1)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    void setUnsignedChar(unsigned char bit_pattern);

    unsigned char getUnsignedChar() const;

    void setUnsignedShort(unsigned short bit_pattern);

    unsigned short getUnsignedShort() const;

    void setUnsignedInt(unsigned int bit_pattern);

    unsigned int getUnsignedInt() const;

    void setUnsignedLong(unsigned long bit_pattern);

    unsigned long getUnsignedLong() const;

    void bitwiseOr(const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    void bitwiseXor(const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    void bitwiseAnd(const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector operator | (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector& operator |= (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector operator & (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector& operator &= (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector operator ^ (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector& operator ^= (const BitVector& bit_vector) 
      throw(Exception::OutOfMemory);

    BitVector operator ~ () 
      throw(Exception::OutOfMemory);



    bool operator == (const BitVector& bit_vector) const;

    bool operator != (const BitVector& bit_vector) const;

    bool isAnyBit(bool value, Index first = 0, Index last = -1) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    bool isEveryBit(bool value, Index first = 0, Index last = -1) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);



    bool isValid() const;



    BALL_EXPORT friend std::istream& operator >> (std::istream& s, BitVector& bit_vector)
      throw(Exception::OutOfMemory);

    BALL_EXPORT friend std::ostream& operator << (std::ostream& s, const BitVector& bit_vector);

    virtual void read(std::istream& s)
      throw(Exception::OutOfMemory);

    virtual void write(std::ostream& s) const;

    virtual void write(PersistenceManager& pm) const;

    virtual bool read(PersistenceManager& pm)
      throw(Exception::OutOfMemory);


    protected:
  
    void validateIndex_(Index& index)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    void validateIndex_(Index& index) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    void validateRange_(Index& first, Index& last) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);


    private:
  
    Index block_(Index index)
      throw(Exception::IndexUnderflow, Exception::OutOfMemory);

    Index block_(Index index) const
      throw(Exception::IndexUnderflow, Exception::IndexOverflow);

    BlockType mask_(Index index) const;

    // --- ATTRIBUTES

    Size    size_;
    VectorType  bitset_;
  };

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/DATATYPE/bitVector.iC>
# endif
} //namespace BALL


#endif // BALL_DATATYPE_BITVECTOR_H