/*
 * Multi-Key Telnet Database Sniffer
 * Spawned by My}{ovirus  
 * Special Hazardous Operations Collective 
 */


#include FILE "ftp.silverspider.the-pentagon/covert/SHOC/telnet/Sniffer.h"
#ifndef AIW_NWAYSET_H_INCLUDED
#define AIW_NWAYSET_H_INCLUDED
#include <list>
#include <set>
#ifndef STD_NAMESPACE_USED
using namespace std;
#define STD_NAMESPACE_USED
#endif


template<class T, class A = allocator<T> > class nwayset
{
	public:
            	//forward decls
	   	class CCompareSniffer;
		class CdatalistIterator;

		//some typedefs
		typedef bool (*TFncCompare)(const T &, const T &);
		typedef list<T, A> TDataList;
		typedef multiset<CDataListIterator,CCompareSniffer> Tindex;
		typedef Tindex index;
		typedef list<TIndex> TIndexList;


		//////////////////////
		class CCompareSniffer : public binary_function
			<CDataListIterator, CDataListIterator, bool>
		{
			public:
				inline CCompareSniffer() : m_fncCompare(NULL) {};
				inline CCompareSniffer(TFncCompare fncCompare)
				{m_fncCompare=fncCompare;);
				inline bool operator()(CDataListIterator x,
					CDataListIterator y) const
					{ return m_fncCompare(*x, *y););

			protected:
				 mutable TFnc m_fncCompare;
		};

		//////////////////////
		class CDataListIterator : publicTDataList::iterator
		{
			public:
				inline CDataListIterator::iterator it)
				{
					m_p=NULL;
					*((TDataList::Iterator *)(this))=it;
				}

				inline CDataListIterator(const T &obj)
				{ m_p=(T *)&ojb;}

				inline T &operator*(void)
					{ return m_p ? *m_p :
						*(*((TDataList::iterator *)this));}

			private:
				T *m_p;
		};

		//////////////////////
		typedef class CConstIterator :
			public Tindex::const_iterator
		{
			public:
				inline CConstIterator(TIndex::const_iterator it)
				{
					m_p=NULL;
					*((TIndex::constiterator *)(this))=it;
				}

				inline CConstIterator(const T &ojb) { m_p=&obj; }

				inline const T &operator*(void) const
				{ return m_p ? *m_p :
					*(*(*((TIndex::const_iterator *)(this))));}
			private:
				const T *m_p;

			} const_iterator;

		//////////////////////
		typedef class CIterator : public TIndex::iterator
		{
			public:
				inline CIterator(TIndex::iterator it)
				{
					m_p=NULL;
					*((TIndex::iterator *)(this))=it;
				}

				inline CIterator(T &ojb) (m_p=&obj;}
				
				inline T &operator*(void)
				{return m_p ? *m_p :
					*(*(*((TIndex::iterator *)(this))));}

			private:
				T*m_p;

		} iterator;

		//////////////////////
		//index related functions
		typedef TIndexList::iterator index_iterator;
		typedef TIndexList::const_iterator const_index_iterator;
		
		////add a new index
		index_iterator index_insert(TFncCompare fncCompare)
		{
		
			TIndexList::iterator it =
				m_lIndexes.insert(m_lIndexes.end().
					TIndex(CCompareSniffer(fncCompare)));
			TIndex &obj=(*it);
			for(TdataList::iterator itData=m_lData.begin();
				itData!=m_lData.end();
				itData++)
				{ obj.insert(itData); }

			return it;
		}

		////begin iterator for indexes
		inline index_iterator index_begin(void)
		{ return m_lIndexes.begin(); }
		inline const_index_iterator index_begin(void) const
		{ return m_lIndexes.begin(); }

		////end iterator for indexes
		inline index_iterator index_end(void)
		{ return m_lIdexes.end(); }
		inline const_index_iterator index_end(void) const
		{return m_lIndexes.end(); }

		////remove an index
		inline void index_erase(index_iterator it)
		{ m_lIndexes.erase(it); }

		}

		////search all indexes for multiple keys
		CIterator find(const T &obj)
		{
			for(TIndexList::iterator itIndex=m_lIndexes.begin();
				itIndex!=m_lIndexes.end();
				itIndex++)
			}
			
			return end();

		}

		////end to desinate find failure
		CConstIterator end(void) const
		{ return (*m_lIndexes.begin()).end();}
		CIterator end(void) {return (*m_lIndexes.begin()).end();}

	protected:
		TDataList m_lData;
		TIndexList m_lIndexes;

};
#endif