BitSet.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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++/String.h++>

#include <iostream>

namespace ccxx {

class COMMONCPP_API BitSet
{
 public:

  class COMMONCPP_API Bit
  {
    friend class BitSet;

   public:

    Bit(const Bit& other);

    Bit& operator=(const Bit& other);

    Bit& operator=(bool val);

    ~Bit();

    operator bool() const;

    Bit& flip();

   private:

    Bit(BitSet& set, uint_t pos);

    BitSet& _set;
    uint_t _pos;
  };

  BitSet(uint_t size);

  BitSet(const BitSet& other);

  BitSet(const String& bits);

  virtual ~BitSet();

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

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

  BitSet& setAll(bool value = true);

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

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

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

  bool isSet(int pos) const;

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

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

  bool isAnySet() const;

  bool isAllSet() const;

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

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

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

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

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

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

  BitSet& flip();

  BitSet& flip(uint_t pos);

  void swap(BitSet &other);

  Bit operator[](int pos);

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

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

  inline uint_t getWordCount() const
  { return(_length); }

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

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

  void setWord(uint_t index, uint32_t word);

  String toString() const;

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

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

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

  BitSet& operator=(const BitSet& other);

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

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

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

  BitSet& operator>>=(uint_t n);

  BitSet& operator<<=(uint_t n);

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

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

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

 private:

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

  uint_t _size;
  uint_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