/*! \file Dummy.h
	\brief Declaration and implementation of the sps::Dummy class. 

	This file is only needed for sps::SparseSetTest.
	
	\sa
	- BitList.h
	- BitTree.h
	- DenseBitVector.h
	- SparseBitVector.h
	- RiceSet.h
	\sa
*/

#ifndef _Dummy_h_included_
#define _Dummy_h_included_

#include "Helpers.h"
#include "Iterator.h"

#include <list>

namespace sps
{
	/*! \brief Dummy implementation of the BitSet interface.
		
		In this implementation all methods are empty. It is used to measure the
		test overhead in sps::SparseSetTest.

		\sa
			- sps::BitList
			- sps::BitTree
			- sps::DenseBitVector
			- sps::SparseBitVector
			- sps::RiceSet
		\sa
	*/
	class Dummy
	{
	public:
		class Iterator : public sps::Iterator
		{
		public:
			Iterator();
			Iterator( const Dummy& rDummy );
			
			virtual bool HasMoreElements() const;
			virtual void Begin();
			virtual void Next();
			virtual size_t operator*() const;

			Iterator& operator=( const Iterator& rOther );
		};

		void Add( size_t nBit );
		void Remove( size_t nBit );
		bool IsEmpty() const;
		bool Contains( size_t nBit ) const;
		bool IsEqual( const Dummy& rOther ) const;
		void Union( const Dummy& rOther );
		void Intersect( const Dummy& rOther );
		void Difference( const Dummy& rOther );
		void Clear();
		Iterator GetIterator() const;
	};

	inline void Dummy::Add( size_t nBit )
	{
	}

	inline void Dummy::Remove( size_t nBit )
	{
	}

	inline bool Dummy::IsEmpty() const
	{
		return true;
	}

	inline bool Dummy::Contains( size_t nBit ) const
	{
		return false;
	}

	inline bool Dummy::IsEqual( const Dummy& rOther ) const
	{
		return false;
	}

	inline void Dummy::Union( const Dummy& rOther )
	{
	}

	inline void Dummy::Intersect( const Dummy& rOther )
	{
	}

	inline void Dummy::Difference( const Dummy& rOther )
	{
	}

	inline void Dummy::Clear()
	{
	}

	inline Dummy::Iterator Dummy::GetIterator() const
	{
		return Dummy::Iterator( *this );
	}


	///////////////////////////////////////////////////////////////////////////
	// Dummy::Iterator implementation
	///////////////////////////////////////////////////////////////////////////

	inline Dummy::Iterator::Iterator()
	{
	}

	inline Dummy::Iterator::Iterator( const Dummy& rBitList )
	{
	}

	inline bool Dummy::Iterator::HasMoreElements() const
	{
		return false;
	}

	inline void Dummy::Iterator::Begin()
	{
	}

	inline void Dummy::Iterator::Next()
	{
	}

	inline size_t Dummy::Iterator::operator*() const
	{
		return -1;
	}

	inline Dummy::Iterator& Dummy::Iterator::operator=( const Dummy::Iterator& rOther )
	{
		return *this;
	}
}

#endif //_Dummy_h_included_