1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/libs/assimp/boost/tuple/tuple.hpp	Sat Feb 01 19:58:19 2014 +0200
     1.3 @@ -0,0 +1,283 @@
     1.4 +// A very small replacement for boost::tuple
     1.5 +// (c) Alexander Gessler, 2008 [alexander.gessler@gmx.net]
     1.6 +
     1.7 +#ifndef BOOST_TUPLE_INCLUDED
     1.8 +#define BOOST_TUPLE_INCLUDED
     1.9 +
    1.10 +namespace boost	{
    1.11 +	namespace detail	{
    1.12 +
    1.13 +		// Represents an empty tuple slot (up to 5 supported)
    1.14 +		struct nulltype {};
    1.15 +
    1.16 +		// For readable error messages
    1.17 +		struct tuple_component_idx_out_of_bounds;
    1.18 +
    1.19 +		// To share some code for the const/nonconst versions of the getters
    1.20 +		template <bool b, typename T>
    1.21 +		struct ConstIf {
    1.22 +			typedef T t;
    1.23 +		};
    1.24 +
    1.25 +		template <typename T>
    1.26 +		struct ConstIf<true,T> {
    1.27 +			typedef const T t;
    1.28 +		};
    1.29 +
    1.30 +		// Predeclare some stuff
    1.31 +		template <typename, unsigned, typename, bool, unsigned> struct value_getter;
    1.32 +
    1.33 +		// Helper to obtain the type of a tuple element
    1.34 +		template <typename T, unsigned NIDX, typename TNEXT, unsigned N /*= 0*/>
    1.35 +		struct type_getter	{
    1.36 +			typedef type_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,N> next_elem_getter;
    1.37 +			typedef typename next_elem_getter::type type;
    1.38 +		};
    1.39 +
    1.40 +		template <typename T, unsigned NIDX, typename TNEXT >
    1.41 +		struct type_getter <T,NIDX,TNEXT,NIDX>	{
    1.42 +			typedef T type;
    1.43 +		};
    1.44 +
    1.45 +		// Base class for all explicit specializations of list_elem
    1.46 +		template <typename T, unsigned NIDX, typename TNEXT >
    1.47 +		struct list_elem_base {
    1.48 +
    1.49 +			// Store template parameters
    1.50 +			typedef TNEXT next_type;
    1.51 +			typedef T type;
    1.52 +
    1.53 +			static const unsigned nidx = NIDX;
    1.54 +		};
    1.55 +
    1.56 +		// Represents an element in the tuple component list
    1.57 +		template <typename T, unsigned NIDX, typename TNEXT >
    1.58 +		struct list_elem : list_elem_base<T,NIDX,TNEXT>{
    1.59 +
    1.60 +			// Real members
    1.61 +			T me;
    1.62 +			TNEXT next;
    1.63 +
    1.64 +			// Get the value of a specific tuple element
    1.65 +			template <unsigned N>
    1.66 +			typename type_getter<T,NIDX,TNEXT,N>::type& get () {
    1.67 +				value_getter <T,NIDX,TNEXT,false,N> s;
    1.68 +				return s(*this);
    1.69 +			}
    1.70 +
    1.71 +			// Get the value of a specific tuple element
    1.72 +			template <unsigned N>
    1.73 +			const typename type_getter<T,NIDX,TNEXT,N>::type& get () const {
    1.74 +				value_getter <T,NIDX,TNEXT,true,N> s;
    1.75 +				return s(*this);
    1.76 +			}
    1.77 +
    1.78 +			// Explicit cast
    1.79 +			template <typename T2, typename TNEXT2 >
    1.80 +			operator list_elem<T2,NIDX,TNEXT2> () const	{
    1.81 +				list_elem<T2,NIDX,TNEXT2> ret;
    1.82 +				ret.me   = (T2)me;
    1.83 +				ret.next = next;
    1.84 +				return ret;
    1.85 +			}
    1.86 +
    1.87 +			// Recursively compare two elements (last element returns always true)
    1.88 +			bool operator == (const list_elem& s) const	{
    1.89 +				return (me == s.me && next == s.next);
    1.90 +			}
    1.91 +		};
    1.92 +
    1.93 +		// Represents a non-used tuple element - the very last element processed
    1.94 +		template <typename TNEXT, unsigned NIDX  >
    1.95 +		struct list_elem<nulltype,NIDX,TNEXT> : list_elem_base<nulltype,NIDX,TNEXT> {
    1.96 +			template <unsigned N, bool IS_CONST = true> struct value_getter		{
    1.97 +				/* just dummy members to produce readable error messages */
    1.98 +				tuple_component_idx_out_of_bounds operator () (typename ConstIf<IS_CONST,list_elem>::t& me);
    1.99 +			};
   1.100 +			template <unsigned N> struct type_getter  {
   1.101 +				/* just dummy members to produce readable error messages */
   1.102 +				typedef tuple_component_idx_out_of_bounds type;
   1.103 +			};
   1.104 +
   1.105 +			// dummy
   1.106 +			list_elem& operator = (const list_elem& other)	{
   1.107 +				return *this;
   1.108 +			}
   1.109 +
   1.110 +			// dummy
   1.111 +			bool operator == (const list_elem& other)	{
   1.112 +				return true;
   1.113 +			}
   1.114 +		};
   1.115 +
   1.116 +		// Represents the absolute end of the list
   1.117 +		typedef list_elem<nulltype,0,int> list_end;
   1.118 +
   1.119 +		// Helper obtain to query the value of a tuple element
   1.120 +		// NOTE: This can't be a nested class as the compiler won't accept a full or
   1.121 +		// partial specialization of a nested class of a non-specialized template
   1.122 +		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST, unsigned N>
   1.123 +		struct value_getter	 {
   1.124 +
   1.125 +			// calling list_elem
   1.126 +			typedef list_elem<T,NIDX,TNEXT> outer_elem;
   1.127 +
   1.128 +			// typedef for the getter for next element
   1.129 +			typedef value_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,
   1.130 +				IS_CONST, N> next_value_getter;
   1.131 +
   1.132 +			typename ConstIf<IS_CONST,typename type_getter<T,NIDX,TNEXT,N>::type>::t&
   1.133 +				operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
   1.134 +
   1.135 +				next_value_getter s;
   1.136 +				return s(me.next);
   1.137 +			}
   1.138 +		};
   1.139 +
   1.140 +		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST>
   1.141 +		struct value_getter <T,NIDX,TNEXT,IS_CONST,NIDX>	{
   1.142 +			typedef list_elem<T,NIDX,TNEXT> outer_elem;
   1.143 +
   1.144 +			typename ConstIf<IS_CONST,T>::t& operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
   1.145 +				return me.me;
   1.146 +			}
   1.147 +		};
   1.148 +	};
   1.149 +
   1.150 +	// A very minimal implementation for up to 5 elements
   1.151 +	template <typename T0  = detail::nulltype,
   1.152 +		      typename T1  = detail::nulltype,
   1.153 +			  typename T2  = detail::nulltype,
   1.154 +			  typename T3  = detail::nulltype,
   1.155 +			  typename T4  = detail::nulltype>
   1.156 +	class tuple	{
   1.157 +
   1.158 +		template <typename T0b,
   1.159 +		      typename T1b,
   1.160 +			  typename T2b,
   1.161 +			  typename T3b,
   1.162 +			  typename T4b >
   1.163 +		friend class tuple;
   1.164 +
   1.165 +	private:
   1.166 +
   1.167 +		typedef detail::list_elem<T0,0,
   1.168 +					detail::list_elem<T1,1,
   1.169 +						detail::list_elem<T2,2,
   1.170 +							detail::list_elem<T3,3,
   1.171 +								detail::list_elem<T4,4,
   1.172 +									detail::list_end > > > > > very_long;
   1.173 +
   1.174 +		very_long m;
   1.175 +
   1.176 +	public:
   1.177 +
   1.178 +		// Get a specific tuple element
   1.179 +		template <unsigned N>
   1.180 +		typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get ()	{
   1.181 +			return m.template get<N>();
   1.182 +		}
   1.183 +
   1.184 +		// ... and the const version
   1.185 +		template <unsigned N>
   1.186 +		const typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get () const	{
   1.187 +			return m.template get<N>();
   1.188 +		}
   1.189 +
   1.190 +
   1.191 +		// comparison operators
   1.192 +		bool operator== (const tuple& other) const	{
   1.193 +			return m == other.m;
   1.194 +		}
   1.195 +
   1.196 +		// ... and the other way round
   1.197 +		bool operator!= (const tuple& other) const	{
   1.198 +			return !(m == other.m);
   1.199 +		}
   1.200 +
   1.201 +		// cast to another tuple - all single elements must be convertible
   1.202 +		template <typename T0b, typename T1b,typename T2b,typename T3b, typename T4b>
   1.203 +		operator tuple <T0b,T1b,T2b,T3b,T4b> () const {
   1.204 +			tuple <T0b,T1b,T2b,T3b,T4b> s;
   1.205 +			s.m = (typename tuple <T0b,T1b,T2b,T3b,T4b>::very_long)m;
   1.206 +			return s;
   1.207 +		}
   1.208 +	};
   1.209 +
   1.210 +	// Another way to access an element ...
   1.211 +	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
   1.212 +	inline typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
   1.213 +			tuple<T0,T1,T2,T3,T4>& m)	{
   1.214 +			return m.template get<N>();
   1.215 +		}
   1.216 +
   1.217 +	// ... and the const version
   1.218 +	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
   1.219 +	inline const typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
   1.220 +			const tuple<T0,T1,T2,T3,T4>& m)	{
   1.221 +			return m.template get<N>();
   1.222 +		}
   1.223 +
   1.224 +	// Constructs a tuple with 5 elements
   1.225 +	template <typename T0,typename T1,typename T2,typename T3,typename T4>
   1.226 +	inline tuple <T0,T1,T2,T3,T4> make_tuple (const T0& t0,
   1.227 +		const T1& t1,const T2& t2,const T3& t3,const T4& t4) {
   1.228 +
   1.229 +		tuple <T0,T1,T2,T3,T4> t;
   1.230 +		t.template get<0>() = t0;
   1.231 +		t.template get<1>() = t1;
   1.232 +		t.template get<2>() = t2;
   1.233 +		t.template get<3>() = t3;
   1.234 +		t.template get<4>() = t4;
   1.235 +		return t;
   1.236 +	}
   1.237 +
   1.238 +	// Constructs a tuple with 4 elements
   1.239 +	template <typename T0,typename T1,typename T2,typename T3>
   1.240 +	inline tuple <T0,T1,T2,T3> make_tuple (const T0& t0,
   1.241 +		const T1& t1,const T2& t2,const T3& t3) {
   1.242 +		tuple <T0,T1,T2,T3> t;
   1.243 +		t.template get<0>() = t0;
   1.244 +		t.template get<1>() = t1;
   1.245 +		t.template get<2>() = t2;
   1.246 +		t.template get<3>() = t3;
   1.247 +		return t;
   1.248 +	}
   1.249 +
   1.250 +	// Constructs a tuple with 3 elements
   1.251 +	template <typename T0,typename T1,typename T2>
   1.252 +	inline tuple <T0,T1,T2> make_tuple (const T0& t0,
   1.253 +		const T1& t1,const T2& t2) {
   1.254 +		tuple <T0,T1,T2> t;
   1.255 +		t.template get<0>() = t0;
   1.256 +		t.template get<1>() = t1;
   1.257 +		t.template get<2>() = t2;
   1.258 +		return t;
   1.259 +	}
   1.260 +
   1.261 +	// Constructs a tuple with 2 elements 
   1.262 +	template <typename T0,typename T1>
   1.263 +	inline tuple <T0,T1> make_tuple (const T0& t0,
   1.264 +		const T1& t1) {
   1.265 +		tuple <T0,T1> t;
   1.266 +		t.template get<0>() = t0;
   1.267 +		t.template get<1>() = t1;
   1.268 +		return t;
   1.269 +	}
   1.270 +
   1.271 +	// Constructs a tuple with 1 elements (well ...)
   1.272 +	template <typename T0>
   1.273 +	inline tuple <T0> make_tuple (const T0& t0) {
   1.274 +		tuple <T0> t;
   1.275 +		t.template get<0>() = t0;
   1.276 +		return t;
   1.277 +	}
   1.278 +
   1.279 +	// Constructs a tuple with 0 elements (well ...)
   1.280 +	inline tuple <> make_tuple () {
   1.281 +		tuple <> t;
   1.282 +		return t;
   1.283 +	}
   1.284 +};
   1.285 +
   1.286 +#endif // !! BOOST_TUPLE_INCLUDED