nuclear@0: // A very small replacement for boost::tuple
nuclear@0: // (c) Alexander Gessler, 2008 [alexander.gessler@gmx.net]
nuclear@0: 
nuclear@0: #ifndef BOOST_TUPLE_INCLUDED
nuclear@0: #define BOOST_TUPLE_INCLUDED
nuclear@0: 
nuclear@0: namespace boost	{
nuclear@0: 	namespace detail	{
nuclear@0: 
nuclear@0: 		// Represents an empty tuple slot (up to 5 supported)
nuclear@0: 		struct nulltype {};
nuclear@0: 
nuclear@0: 		// For readable error messages
nuclear@0: 		struct tuple_component_idx_out_of_bounds;
nuclear@0: 
nuclear@0: 		// To share some code for the const/nonconst versions of the getters
nuclear@0: 		template <bool b, typename T>
nuclear@0: 		struct ConstIf {
nuclear@0: 			typedef T t;
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		template <typename T>
nuclear@0: 		struct ConstIf<true,T> {
nuclear@0: 			typedef const T t;
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		// Predeclare some stuff
nuclear@0: 		template <typename, unsigned, typename, bool, unsigned> struct value_getter;
nuclear@0: 
nuclear@0: 		// Helper to obtain the type of a tuple element
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT, unsigned N /*= 0*/>
nuclear@0: 		struct type_getter	{
nuclear@0: 			typedef type_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,N> next_elem_getter;
nuclear@0: 			typedef typename next_elem_getter::type type;
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT >
nuclear@0: 		struct type_getter <T,NIDX,TNEXT,NIDX>	{
nuclear@0: 			typedef T type;
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		// Base class for all explicit specializations of list_elem
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT >
nuclear@0: 		struct list_elem_base {
nuclear@0: 
nuclear@0: 			// Store template parameters
nuclear@0: 			typedef TNEXT next_type;
nuclear@0: 			typedef T type;
nuclear@0: 
nuclear@0: 			static const unsigned nidx = NIDX;
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		// Represents an element in the tuple component list
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT >
nuclear@0: 		struct list_elem : list_elem_base<T,NIDX,TNEXT>{
nuclear@0: 
nuclear@0: 			// Real members
nuclear@0: 			T me;
nuclear@0: 			TNEXT next;
nuclear@0: 
nuclear@0: 			// Get the value of a specific tuple element
nuclear@0: 			template <unsigned N>
nuclear@0: 			typename type_getter<T,NIDX,TNEXT,N>::type& get () {
nuclear@0: 				value_getter <T,NIDX,TNEXT,false,N> s;
nuclear@0: 				return s(*this);
nuclear@0: 			}
nuclear@0: 
nuclear@0: 			// Get the value of a specific tuple element
nuclear@0: 			template <unsigned N>
nuclear@0: 			const typename type_getter<T,NIDX,TNEXT,N>::type& get () const {
nuclear@0: 				value_getter <T,NIDX,TNEXT,true,N> s;
nuclear@0: 				return s(*this);
nuclear@0: 			}
nuclear@0: 
nuclear@0: 			// Explicit cast
nuclear@0: 			template <typename T2, typename TNEXT2 >
nuclear@0: 			operator list_elem<T2,NIDX,TNEXT2> () const	{
nuclear@0: 				list_elem<T2,NIDX,TNEXT2> ret;
nuclear@0: 				ret.me   = (T2)me;
nuclear@0: 				ret.next = next;
nuclear@0: 				return ret;
nuclear@0: 			}
nuclear@0: 
nuclear@0: 			// Recursively compare two elements (last element returns always true)
nuclear@0: 			bool operator == (const list_elem& s) const	{
nuclear@0: 				return (me == s.me && next == s.next);
nuclear@0: 			}
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		// Represents a non-used tuple element - the very last element processed
nuclear@0: 		template <typename TNEXT, unsigned NIDX  >
nuclear@0: 		struct list_elem<nulltype,NIDX,TNEXT> : list_elem_base<nulltype,NIDX,TNEXT> {
nuclear@0: 			template <unsigned N, bool IS_CONST = true> struct value_getter		{
nuclear@0: 				/* just dummy members to produce readable error messages */
nuclear@0: 				tuple_component_idx_out_of_bounds operator () (typename ConstIf<IS_CONST,list_elem>::t& me);
nuclear@0: 			};
nuclear@0: 			template <unsigned N> struct type_getter  {
nuclear@0: 				/* just dummy members to produce readable error messages */
nuclear@0: 				typedef tuple_component_idx_out_of_bounds type;
nuclear@0: 			};
nuclear@0: 
nuclear@0: 			// dummy
nuclear@0: 			list_elem& operator = (const list_elem& other)	{
nuclear@0: 				return *this;
nuclear@0: 			}
nuclear@0: 
nuclear@0: 			// dummy
nuclear@0: 			bool operator == (const list_elem& other)	{
nuclear@0: 				return true;
nuclear@0: 			}
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		// Represents the absolute end of the list
nuclear@0: 		typedef list_elem<nulltype,0,int> list_end;
nuclear@0: 
nuclear@0: 		// Helper obtain to query the value of a tuple element
nuclear@0: 		// NOTE: This can't be a nested class as the compiler won't accept a full or
nuclear@0: 		// partial specialization of a nested class of a non-specialized template
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST, unsigned N>
nuclear@0: 		struct value_getter	 {
nuclear@0: 
nuclear@0: 			// calling list_elem
nuclear@0: 			typedef list_elem<T,NIDX,TNEXT> outer_elem;
nuclear@0: 
nuclear@0: 			// typedef for the getter for next element
nuclear@0: 			typedef value_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,
nuclear@0: 				IS_CONST, N> next_value_getter;
nuclear@0: 
nuclear@0: 			typename ConstIf<IS_CONST,typename type_getter<T,NIDX,TNEXT,N>::type>::t&
nuclear@0: 				operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
nuclear@0: 
nuclear@0: 				next_value_getter s;
nuclear@0: 				return s(me.next);
nuclear@0: 			}
nuclear@0: 		};
nuclear@0: 
nuclear@0: 		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST>
nuclear@0: 		struct value_getter <T,NIDX,TNEXT,IS_CONST,NIDX>	{
nuclear@0: 			typedef list_elem<T,NIDX,TNEXT> outer_elem;
nuclear@0: 
nuclear@0: 			typename ConstIf<IS_CONST,T>::t& operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
nuclear@0: 				return me.me;
nuclear@0: 			}
nuclear@0: 		};
nuclear@0: 	};
nuclear@0: 
nuclear@0: 	// A very minimal implementation for up to 5 elements
nuclear@0: 	template <typename T0  = detail::nulltype,
nuclear@0: 		      typename T1  = detail::nulltype,
nuclear@0: 			  typename T2  = detail::nulltype,
nuclear@0: 			  typename T3  = detail::nulltype,
nuclear@0: 			  typename T4  = detail::nulltype>
nuclear@0: 	class tuple	{
nuclear@0: 
nuclear@0: 		template <typename T0b,
nuclear@0: 		      typename T1b,
nuclear@0: 			  typename T2b,
nuclear@0: 			  typename T3b,
nuclear@0: 			  typename T4b >
nuclear@0: 		friend class tuple;
nuclear@0: 
nuclear@0: 	private:
nuclear@0: 
nuclear@0: 		typedef detail::list_elem<T0,0,
nuclear@0: 					detail::list_elem<T1,1,
nuclear@0: 						detail::list_elem<T2,2,
nuclear@0: 							detail::list_elem<T3,3,
nuclear@0: 								detail::list_elem<T4,4,
nuclear@0: 									detail::list_end > > > > > very_long;
nuclear@0: 
nuclear@0: 		very_long m;
nuclear@0: 
nuclear@0: 	public:
nuclear@0: 
nuclear@0: 		// Get a specific tuple element
nuclear@0: 		template <unsigned N>
nuclear@0: 		typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get ()	{
nuclear@0: 			return m.template get<N>();
nuclear@0: 		}
nuclear@0: 
nuclear@0: 		// ... and the const version
nuclear@0: 		template <unsigned N>
nuclear@0: 		const typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get () const	{
nuclear@0: 			return m.template get<N>();
nuclear@0: 		}
nuclear@0: 
nuclear@0: 
nuclear@0: 		// comparison operators
nuclear@0: 		bool operator== (const tuple& other) const	{
nuclear@0: 			return m == other.m;
nuclear@0: 		}
nuclear@0: 
nuclear@0: 		// ... and the other way round
nuclear@0: 		bool operator!= (const tuple& other) const	{
nuclear@0: 			return !(m == other.m);
nuclear@0: 		}
nuclear@0: 
nuclear@0: 		// cast to another tuple - all single elements must be convertible
nuclear@0: 		template <typename T0b, typename T1b,typename T2b,typename T3b, typename T4b>
nuclear@0: 		operator tuple <T0b,T1b,T2b,T3b,T4b> () const {
nuclear@0: 			tuple <T0b,T1b,T2b,T3b,T4b> s;
nuclear@0: 			s.m = (typename tuple <T0b,T1b,T2b,T3b,T4b>::very_long)m;
nuclear@0: 			return s;
nuclear@0: 		}
nuclear@0: 	};
nuclear@0: 
nuclear@0: 	// Another way to access an element ...
nuclear@0: 	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
nuclear@0: 	inline typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
nuclear@0: 			tuple<T0,T1,T2,T3,T4>& m)	{
nuclear@0: 			return m.template get<N>();
nuclear@0: 		}
nuclear@0: 
nuclear@0: 	// ... and the const version
nuclear@0: 	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
nuclear@0: 	inline const typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
nuclear@0: 			const tuple<T0,T1,T2,T3,T4>& m)	{
nuclear@0: 			return m.template get<N>();
nuclear@0: 		}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 5 elements
nuclear@0: 	template <typename T0,typename T1,typename T2,typename T3,typename T4>
nuclear@0: 	inline tuple <T0,T1,T2,T3,T4> make_tuple (const T0& t0,
nuclear@0: 		const T1& t1,const T2& t2,const T3& t3,const T4& t4) {
nuclear@0: 
nuclear@0: 		tuple <T0,T1,T2,T3,T4> t;
nuclear@0: 		t.template get<0>() = t0;
nuclear@0: 		t.template get<1>() = t1;
nuclear@0: 		t.template get<2>() = t2;
nuclear@0: 		t.template get<3>() = t3;
nuclear@0: 		t.template get<4>() = t4;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 4 elements
nuclear@0: 	template <typename T0,typename T1,typename T2,typename T3>
nuclear@0: 	inline tuple <T0,T1,T2,T3> make_tuple (const T0& t0,
nuclear@0: 		const T1& t1,const T2& t2,const T3& t3) {
nuclear@0: 		tuple <T0,T1,T2,T3> t;
nuclear@0: 		t.template get<0>() = t0;
nuclear@0: 		t.template get<1>() = t1;
nuclear@0: 		t.template get<2>() = t2;
nuclear@0: 		t.template get<3>() = t3;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 3 elements
nuclear@0: 	template <typename T0,typename T1,typename T2>
nuclear@0: 	inline tuple <T0,T1,T2> make_tuple (const T0& t0,
nuclear@0: 		const T1& t1,const T2& t2) {
nuclear@0: 		tuple <T0,T1,T2> t;
nuclear@0: 		t.template get<0>() = t0;
nuclear@0: 		t.template get<1>() = t1;
nuclear@0: 		t.template get<2>() = t2;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 2 elements 
nuclear@0: 	template <typename T0,typename T1>
nuclear@0: 	inline tuple <T0,T1> make_tuple (const T0& t0,
nuclear@0: 		const T1& t1) {
nuclear@0: 		tuple <T0,T1> t;
nuclear@0: 		t.template get<0>() = t0;
nuclear@0: 		t.template get<1>() = t1;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 1 elements (well ...)
nuclear@0: 	template <typename T0>
nuclear@0: 	inline tuple <T0> make_tuple (const T0& t0) {
nuclear@0: 		tuple <T0> t;
nuclear@0: 		t.template get<0>() = t0;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Constructs a tuple with 0 elements (well ...)
nuclear@0: 	inline tuple <> make_tuple () {
nuclear@0: 		tuple <> t;
nuclear@0: 		return t;
nuclear@0: 	}
nuclear@0: };
nuclear@0: 
nuclear@0: #endif // !! BOOST_TUPLE_INCLUDED