/*
* You may use this code for nonprofit projects.
* You have to include this header in any copy of that code.
*
* Copyright @ Eduard Aumüller 2005
* basiror@gmx.de
*/

/*
* bitpack just serves for fast and easy bitpacking
*/
namespace cross
{
	//set_mask[n] & value to ensure only proper bit setting
	const int set_masks[33] = {
		0x00000000,
		0x00000001,		0x00000003,		0x00000007,		0x0000000F,
		0x0000001F,		0x0000003F,		0x0000007F,		0x000000FF,
		0x000001FF,		0x000003FF,		0x000007FF,		0x00000FFF,
		0x00001FFF,		0x00003FFF,		0x00007FFF,		0x0000FFFF,
		0x0001FFFF,		0x0003FFFF,		0x0007FFFF,		0x000FFFFF,
		0x001FFFFF,		0x003FFFFF,		0x007FFFFF,		0x00FFFFFF,
		0x01FFFFFF,		0x03FFFFFF,		0x07FFFFFF,		0x0FFFFFFF,
		0x1FFFFFFF,		0x3FFFFFFF,		0x7FFFFFFF,		0xFFFFFFFF
	};
	template<uint32 bits, bool networkbyteorder = false> class bitpack
	{
	public:
		enum bitpack_m
		{			
			MAX_ELEMENT_BITS = (sizeof(uint32)*8),
			MAX_ARRAY_ELEMENTS = (((bits-1)/(sizeof(uint32)*8))+1),//bits -1 should solve the case of a additional element
			BITPACK_ERROR = 0xFFFFFFFF
		};
		bitpack()
		{
			std::fill<uint32*,uint32>(&m_Array[0],&m_Array[MAX_ARRAY_ELEMENTS],0);
		};
		//maximum bit index
		uint32	max_idx()
		{
			return static_cast<uint32>(bits -1);
		};
		//set all bits
		void	set()
		{
			std::fill<uint32*,uint32>(&m_Array[0],&m_Array[MAX_ARRAY_ELEMENTS],set_mask[32]);
		};
		//set bit at position idx to value
		void	set(uint32 idx, BOOL value=TRUE)
		{
			set(idx,1,static_cast<uint32>(value));
		};
		//set n bits of value make sure no bit above (n-1)th is set
		void	set(uint32 idx,uint32 n, uint32 value)
		{
			uint32	i = idx / MAX_ELEMENT_BITS;
			uint32	mod = idx % MAX_ELEMENT_BITS;
			uint32	m = MAX_ELEMENT_BITS - mod;

			if(i >= MAX_ARRAY_ELEMENTS)
				return;

			//only 32 bits available to set
			if(n > MAX_ELEMENT_BITS)
				return;

			value&= set_masks[n];

			//set bits at position idx
			m_Array &=~ set_masks[n]<<mod;
			m_Array |= value<<mod;

			if(networkbyteorder == true)
				m_Arrayhtonl = htonl(m_Array);

			//uint32 crossing m bits were written
			if(m < n && (i+1 < MAX_ARRAY_ELEMENTS))
			{
				m_Array[i+1] &=~ set_masks[n]>>m;
				m_Array[i+1] |= value>>m;

				if(networkbyteorder == true)
					m_Arrayhtonl[i+1] = htonl(m_Array[i+1]);
			}
		};
		//read n bits
		uint32 read(uint32 idx, uint32 n)
		{
			uint32 i = idx / MAX_ELEMENT_BITS;
			uint32 mod = idx% MAX_ELEMENT_BITS;
			uint32 m = MAX_ELEMENT_BITS - mod;
			uint32 value = 0;

			if(i >= MAX_ARRAY_ELEMENTS)
				return BITPACK_ERROR;

			//we can only read 32 bits at once
			if(n > MAX_ELEMENT_BITS)
				return BITPACK_ERROR;

			value = m_Array>>mod;

			//anything left to read? shift left for to save the m bits we already wrote!
			if(m < n && (i+1 < MAX_ARRAY_ELEMENTS))
				value |= m_Array[i+1]<<m;

			//now mask all n bits 
			value&= set_masks[n];

			return value;

		};
		//clear all bits
		void	clear()
		{
			std::fill<uint32*,uint32>(&m_Array[0],&m_Array[MAX_ARRAY_ELEMENTS],0);
		};
		//returns the data array in network byte order optionally
		const byte8* data(BOOL bNetByteOrder = FALSE)
		{
			if(bNetByteOrder == FALSE)
				return reinterpret_cast<byte8*>(m_Array);

			return reinterpret_cast<byte8*>(m_Arrayhtonl);
		}
		void print()
		{
			for(int i=0;i<MAX_ARRAY_ELEMENTS;i++)
			{
				std::cout<<i<<" "<<m_Array<<std::endl;
			}
		};
	private:
		uint32	m_Array[MAX_ARRAY_ELEMENTS];
		uint32	m_Arrayhtonl[MAX_ARRAY_ELEMENTS];
	};
};