/****************************************************************************
 * [S]imulated [M]edieval [A]dventure multi[U]ser [G]ame      |				*
 * -----------------------------------------------------------|   \\._.//	*
 * SmaugWiz (C) 1998 by Russ Pillsbury (Windows NT version)   |   (0...0)	*
 * -----------------------------------------------------------|    ).:.(	*
 * SMAUG (C) 1994, 1995, 1996 by Derek Snider                 |    {o o}	*
 * -----------------------------------------------------------|   / ' ' \	*
 * SMAUG code team: Thoric, Altrag, Blodkai, Narn, Haus,      |~'~.VxvxV.~'~*
 * Scryn, Swordbearer, Rennard, Tricops, and Gorog.           |				*
 * ------------------------------------------------------------------------ *
 * Merc 2.1 Diku Mud improvments copyright (C) 1992, 1993 by Michael        *
 * Chastain, Michael Quan, and Mitchell Tse.                                *
 * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,          *
 * Michael Seifert, Hans Henrik Staerfeldt, Tom Madsen, and Katja Nyboe.    *
 * ------------------------------------------------------------------------ *
 *			    Bit Vectors Interface file									*
 ***************************************************************************/

#ifndef	BITVECTOR_H
#define	BITVECTOR_H

extern	int		ConvertBvToBit (int bv);

class CIntVector {
public:
			CIntVector () { Empty (); }
	void	Empty () { bits = 0; }
	BOOL	IsEmpty () { return bits == 0; }
	BOOL	IsSet (UINT bit) const
			{ ASSERT (bit < 32); return (bits & (1 << bit)) != 0; }
	void	SetBit (UINT bit)
			{ ASSERT (bit < 32); bits |= (1 << bit); }
	void	ClrBit (UINT bit)
			{ ASSERT (bit < 32); bits &= ~(1 << bit); }
	void	ToggleBit (UINT bit)
			{ ASSERT (bit < 32); bits ^= (1 << bit); }
	CString	PrintVector () { CString s; s.Format ("%d", bits); return s; }

	BOOL	operator== (CIntVector& in) const { return bits == in.bits; }
	BOOL	operator!= (CIntVector& in) const { return bits != in.bits; }

	const CIntVector& operator= (int v) { bits = v; return *this; }
	const CIntVector& operator= (CIntVector& in)
			{ bits = in.bits; return *this; }

	int		bits;
};


class CBitVector {
public:
			CBitVector () { Empty (); }
			CBitVector (int b) { Empty (); bits [0] = b; }
			CBitVector (const CBitVector& in) { *this = in; }
	void	Empty () { memset (bits, 0, sizeof (bits)); }
	BOOL	IsEmpty () const
			{ for (int i=0; i<4; ++i) if (bits[i]) return FALSE; return TRUE; }
	void	SetBits (const CBitVector& in);
	void	ClearBits (const CBitVector& in);
	
	BOOL	IsSet (UINT bit) const
			{ ASSERT (bit < 128); return (bits [bit/32] & (1 << (bit % 32))) != 0; }
	void	Set (UINT bit, BOOL f) { if (f) SetBit (bit); else ClrBit (bit); }
	void	SetBit (UINT bit)
			{ ASSERT (bit < 128); bits [bit/32] |= (1 << (bit % 32)); }
	void	ClrBit (UINT bit)
			{ ASSERT (bit < 128); bits [bit/32] &= ~(1 << (bit % 32)); }
	void	ToggleBit (UINT bit)
			{ ASSERT (bit < 128); bits [bit/32] ^= (1 << (bit % 32)); }
	void	SetOnly (int bit) { Empty (); SetBit (bit); }
	CString	PrintVector () const;
	CString	PrintString (const char* names [], int size) const;
	void	Parse (char*& pLine);
	void	ParseString (char*& pLine, const char* names [], int size);

	BOOL	operator== (const CBitVector& in) const;
	BOOL	operator!= (const CBitVector& in) const { return ! (*this == in); }
	const CBitVector& operator= (const CBitVector& in);
	
private:
	int		bits [4];
};

#endif