//  boost numeric_promotion.hpp header file  ----------------------------------------//

//  (C) Copyright Stephen Nutt 2003. Permission to copy, use, modify, sell
//  and distribute this software is granted provided this copyright
//  notice appears in all copies. This software is provided "as is" without
//  express or implied warranty, and with no claim as to its suitability for
//  any purpose.

//  See http://www.boost.org for most recent version including documentation.

//  Revision History
//   01 Mar 03  Initial version


#ifndef BOOST_NUMERIC_PROMOTION_HPP
#define BOOST_NUMERIC_PROMOTION_HPP

#include <boost/integer.hpp>

namespace boost
{
	namespace numeric_promotion
	{
		template <typename numeric_type> struct priority_boost { BOOST_STATIC_CONSTANT (int, boost = 0); };
		template <> struct priority_boost <char> { BOOST_STATIC_CONSTANT (int, boost = 0x10); };
		template <> struct priority_boost <signed char> { BOOST_STATIC_CONSTANT (int, boost = 0x10); };
		template <> struct priority_boost <unsigned char> { BOOST_STATIC_CONSTANT (int, boost = 0x10); };
		template <> struct priority_boost <short> { BOOST_STATIC_CONSTANT (int, boost = 0x20); };
		template <> struct priority_boost <unsigned short> { BOOST_STATIC_CONSTANT (int, boost = 0x20); };
		template <> struct priority_boost <int> { BOOST_STATIC_CONSTANT (int, boost = 0x30); };
		template <> struct priority_boost <unsigned> { BOOST_STATIC_CONSTANT (int, boost = 0x30); };
		template <> struct priority_boost <long> { BOOST_STATIC_CONSTANT (int, boost = 0x40); };
		template <> struct priority_boost <unsigned long> { BOOST_STATIC_CONSTANT (int, boost = 0x40); };
		template <> struct priority_boost <__int64> { BOOST_STATIC_CONSTANT (int, boost = 0x50); };
		template <> struct priority_boost <unsigned __int64> { BOOST_STATIC_CONSTANT (int, boost = 0x50); };

		template <> struct priority_boost <float> { BOOST_STATIC_CONSTANT (int, boost = 0x10); };
		template <> struct priority_boost <double> { BOOST_STATIC_CONSTANT (int, boost = 0x20); };
		template <> struct priority_boost <long double> { BOOST_STATIC_CONSTANT (int, boost = 0x30); };

		template <typename integer_type> struct unsigned_type { typedef integer_type type; };
		template <> struct unsigned_type <char> { typedef unsigned char type; };
		template <> struct unsigned_type <signed char> { typedef unsigned char type; };
		template <> struct unsigned_type <short> { typedef unsigned short type; };
		template <> struct unsigned_type <int> { typedef unsigned type; };
		template <> struct unsigned_type <long> { typedef unsigned long type; };
		template <> struct unsigned_type <__int64> { typedef unsigned __int64 type; };

		template <typename numeric_type, bool make_unsigned>
		struct make_type
		{
			template <bool is_unsigned> struct make_type_detail;
			template <> struct make_type_detail <false> { typedef numeric_type type; };
			template <> struct make_type_detail <true> { typedef unsigned_type<numeric_type>::type type; };

			typedef make_type_detail<make_unsigned>::type type;
		};

		template <typename type>
		struct priority_base
		{
			BOOST_STATIC_CONSTANT (int, base = std::numeric_limits<type>::is_integer ? 0x4000 : 0x8000);
		};

		template <typename type>
		struct numeric_priority : priority_base <type>, priority_boost <type>
		{
			BOOST_STATIC_CONSTANT (int, digits = std::numeric_limits<type>::digits + std::numeric_limits<type>::is_signed);
			BOOST_STATIC_CONSTANT (int, priority = base + digits * 256 + boost);
		};

		template <typename type1, typename type2>
		struct promote_type_base
		{
			template <int type> struct promote_type_detail;
			template <> struct promote_type_detail <1> { typedef type1 type; };
			template <> struct promote_type_detail <2> { typedef type2 type; };

			BOOST_STATIC_CONSTANT (int, promoted_type_index = numeric_promotion::numeric_priority<type1>::priority > numeric_promotion::numeric_priority<type2>::priority ? 1 : 2);
			typedef promote_type_detail<promoted_type_index>::type winning_type;
			typedef promote_type_detail<3 - promoted_type_index>::type losing_type;
		};

		template <typename type1, typename type2>
		struct promote_integer_type : promote_type_base <type1, type2>
		{
			typedef std::numeric_limits<winning_type> winning_limits;
			typedef std::numeric_limits<losing_type> losing_limits;

			BOOST_STATIC_CONSTANT (int, force_unsigned = winning_limits::is_signed && !losing_limits::is_signed && (losing_limits::digits > winning_limits::digits));
			typedef make_type<winning_type, force_unsigned>::type type;
		};
	};

	template <typename type1, typename type2>
	struct promote_numeric_type
	{
		template <bool is_integer> struct promote_numeric_type_detail;
		template <> struct promote_numeric_type_detail <true> { typedef numeric_promotion::promote_integer_type<type1, type2>::type type; };
		template <> struct promote_numeric_type_detail <false> { typedef numeric_promotion::promote_type_base<type1, type2>::winning_type type; };

		BOOST_STATIC_CONSTANT (int, types_are_integer = std::numeric_limits<type1>::is_integer && std::numeric_limits<type2>::is_integer);
		typedef promote_numeric_type_detail<types_are_integer>::type type;
	};
};

#endif // BOOST_NUMERIC_PROMOTION_HPP