BitSet.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2009  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_BitSet_hxx
#define __ccxx_BitSet_hxx

#include <commonc++/Common.h++>
#include <commonc++/OutOfBoundsException.h++>
#include <commonc++/String.h++>

#include <iostream>

namespace ccxx {

class COMMONCPP_API BitSet
{
  public:

  class COMMONCPP_API Bit
  {
    friend class BitSet;

    public:

    Bit(const Bit &other) throw();

    Bit& operator=(const Bit& other) throw();

    Bit& operator=(bool val) throw();

    ~Bit() throw();

    operator bool() const throw();

    Bit& flip() throw();

    private:

    Bit(BitSet& set, uint_t pos) throw();

    BitSet& _set;
    uint_t _pos;
  };

  BitSet(uint_t size);

  BitSet(const BitSet& other);

  BitSet(const String& bits);

  virtual ~BitSet() throw();

  BitSet& set(uint_t pos, bool value = true) throw();

  BitSet& setRange(uint_t startPos, uint_t endPos, bool value = true)
    throw();

  BitSet& setAll(bool value = true) throw();

  inline BitSet& clear(uint_t pos) throw()
  { return(set(pos, false)); }

  inline BitSet& clearRange(uint_t startPos, uint_t endPos) throw()
  { return(setRange(startPos, endPos, false)); }

  inline BitSet& clearAll() throw()
  { return(setAll(false)); }

  bool isSet(uint_t pos) const throw();

  inline bool get(uint_t pos) const throw()
  { return(isSet(pos)); }

  inline bool isClear(uint_t pos) const throw()
  { return(! isSet(pos)); }

  bool isAnySet() const throw();

  bool isAllSet() const throw();

  inline bool isAllClear() const throw()
  { return(! isAnySet()); }

  inline int nextSetBit(uint_t startPos) const throw()
  { return(_nextBit(startPos, true)); }

  inline int firstSetBit() const throw()
  { return(_nextBit(0, true)); }

  inline int nextClearBit(uint_t startPos) const throw()
  { return(_nextBit(startPos, false)); }

  inline int firstClearBit() const throw()
  { return(_nextBit(0, false)); }

  inline bool operator!() const throw()
  { return(! isAnySet()); }

  BitSet& flip() throw();

  BitSet& flip(uint_t pos) throw(OutOfBoundsException);

  void swap(BitSet &other) throw(OutOfBoundsException);

  Bit operator[](uint_t pos) throw(OutOfBoundsException);

  inline bool operator[](uint_t pos) const throw()
  { return(isSet(pos)); }

  inline uint_t getSize() const throw()
  { return(_size); }

  inline size_t getWordCount() const throw()
  { return(_length); }

  inline uint32_t getWord(uint_t index) const throw()
  { return(index >= _length ? 0 : _words[index]); }

  inline uint32_t getWordDiff(uint_t index, uint32_t other) const throw()
  { return(getWord(index) ^ other); }

  void setWord(uint_t index, uint32_t word) throw();

  String toString() const;

  void write(std::ostream &stream) const;

  bool operator==(const BitSet& other) const throw();

  inline bool operator!=(const BitSet& other) const throw()
  { return(! operator==(other)); }

  BitSet& operator=(const BitSet& other);

  BitSet& operator|=(const BitSet& other) throw(OutOfBoundsException);

  BitSet& operator&=(const BitSet& other) throw(OutOfBoundsException);

  BitSet& operator^=(const BitSet& other) throw(OutOfBoundsException);

  BitSet& operator>>=(size_t n) throw();

  BitSet& operator<<=(size_t n) throw();

  inline BitSet operator>>(size_t n) const
  { return(BitSet(*this) >>= n); }

  inline BitSet operator<<(size_t n) const
  { return(BitSet(*this) <<= n); }

  inline BitSet operator~() const throw()
  { return(BitSet(*this).flip()); }

  private:

  void _init(uint_t size);
  int _nextBit(uint_t startPos, bool set) const throw();

  uint_t _size;
  size_t _length;
  uint32_t *_words;
  uint32_t _tailMask;
};

inline std::ostream& operator<<(std::ostream &stream, const BitSet &bs)
{
  bs.write(stream);
  return(stream);
}

}; // namespace ccxx

#endif // __ccxx_BitSet_hxx

/* end of header file */