/***************************************************************************

*                         Arrays of Arbitrary Bit Length

*

*   File    : bitarray.h

*   Purpose : Header file for class supporting the creation and

*             manipulation of arbitrary length arrays of bits.

*   Author  : Michael Dipperstein

*   Date    : July 23, 2004

*

****************************************************************************

*   HISTORY

*

*   $Id: bitarray.h,v 1.5 2010/02/04 03:31:43 michael Exp $

*   $Log: bitarray.h,v $

*   Revision 1.5  2010/02/04 03:31:43  michael

*   Replaced vector<unsigned char> with an array of unsigned char.

*

*   Made updates for GCC 4.4.

*

*   Revision 1.4  2007/08/06 05:23:12  michael

*   Updated for LGPL Version 3.

*

*   All methods that don't modify object have been made

*   const to increase functionality of const bit_array_c.

*

*   All assignment operators return a reference to the object being assigned a value so that operator chaining will work.

*

*   Added >> and << operators.

*

*   Revision 1.3  2006/04/30 23:34:07  michael

*   Improved performance by incorporating Benjamin Schindler's

*   <bschindler@student.ethz.ch> changes to pass arguments as a reference.

*

*   Revision 1.2  2004/08/05 22:17:04  michael

*   Add overloads for bitwise operators returning values.

*   Add a more natural looking way to set bit values.

*

*   Revision 1.1.1.1  2004/08/04 13:28:20  michael

*   bit_array_c

*

****************************************************************************

*

* Bitarray: An ANSI C++ class for manipulating arbitrary length bit arrays

* Copyright (C) 2004, 2006-2007, 2010 by

*       Michael Dipperstein (mdipper@alumni.engr.ucsb.edu)

*

* This file is part of the bit array library.

*

* The bit array library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 3 of the

* License, or (at your option) any later version.

*

* The bit array 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 Lesser

* General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>.

*

***************************************************************************/

#ifndef BIT_ARRAY_H

#define BIT_ARRAY_H

/***************************************************************************

*                             INCLUDED FILES

***************************************************************************/

#include <ostream>

/***************************************************************************

*                            TYPE DEFINITIONS

***************************************************************************/

typedef unsigned char (*TBitInChar)(const unsigned int aBit);

template <TBitInChar F>

class BitArray;

//Bits are indexed: 76543210

inline unsigned char HighBitHighIndex(const unsigned int aBit) { return (1 << (((aBit)  % CHAR_BIT)));};

//Bits are indexed: 01234567

inline unsigned char HighBitLowIndex(const unsigned int aBit) { return (1 << (CHAR_BIT - 1 - ((aBit)  % CHAR_BIT)));};

/**

*/

template <TBitInChar F>

class BitArrayIndex

{

    public:

        BitArrayIndex(BitArray<F> *array, const unsigned int index);

        /* assignment */

        void operator=(const bool src);

    private:

        BitArray<F> *m_BitArray;        /* array index applies to */

        unsigned int m_Index;           /* index of bit in array */

};

/**

TODO: Derive a Bit Frame class from this one for X Y access to pixels.

*/

template <TBitInChar F>

class BitArray

{

    public:

        BitArray(const int numBits);

        BitArray(unsigned char *array, const int numBits, bool aOwnsBuffer);

        virtual ~BitArray(void);

        void Dump(std::ostream &outStream);

        const unsigned int SizeInBits() { return m_NumBits; }

        const unsigned int SizeInBytes() { return m_SizeInBytes; }

        /* set/clear functions */

        void SetAll(void);

        void ClearAll(void);

        void SetBit(const unsigned int bit);

		void SetBitValue(const unsigned int bit, bool aValue);

        void ClearBit(const unsigned int bit);

        BitArrayIndex<F> operator()(const unsigned int bit);

        /* boolean operator */

        bool operator[](const unsigned int bit) const;

        bool operator==(const BitArray<F> &other) const;

        bool operator!=(const BitArray<F> &other) const;

        bool operator<(const BitArray<F> &other) const;

        bool operator<=(const BitArray<F> &other) const;

        bool operator>(const BitArray<F> &other) const;

        bool operator>=(const BitArray<F> &other) const;

        /* bitwise operators */

        BitArray<F> operator&(const BitArray<F> &other) const;

        BitArray<F> operator^(const BitArray<F> &other) const;

        BitArray<F> operator|(const BitArray<F> &other) const;

        BitArray<F> operator~(void) const;

        BitArray<F> operator<<(const unsigned int count) const;

        BitArray<F> operator>>(const unsigned int count) const;

        /* increment/decrement */

        BitArray<F>& operator++(void);          /* prefix */

        BitArray<F>& operator++(int dummy);     /* postfix */

        BitArray<F>& operator--(void);          /* prefix */

        BitArray<F>& operator--(int dummy);     /* postfix */

        /* assignments */

        BitArray<F>& operator=(const BitArray<F> &src);

        BitArray<F>& operator&=(const BitArray<F> &src);

        BitArray<F>& operator^=(const BitArray<F> &src);

        BitArray<F>& operator|=(const BitArray<F> &src);

        BitArray<F>& Not(void);                 /* negate (~=) */

        BitArray<F>& operator<<=(unsigned const int shifts);

        BitArray<F>& operator>>=(unsigned const int shifts);

		unsigned char* Ptr(){return m_Array;}

		const unsigned char* Ptr() const{return m_Array;}

    protected:

        unsigned int m_NumBits;                 /* number of bits in the array */

		unsigned int m_SizeInBytes;

        unsigned char *m_Array;                 /* vector of characters */

        bool m_OwnsBuffer;

};

typedef BitArray<HighBitHighIndex> BitArrayHigh;

typedef BitArray<HighBitLowIndex> BitArrayLow;

#endif  /* ndef BIT_ARRAY_H */