// (C) Copyright David Abrahams 2001, Howard Hinnant 2001.

 //

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 //

 // Template class numeric_traits<Number> --

 //

 //    Supplies:

 //

 //      typedef difference_type -- a type used to represent the difference

 //      between any two values of Number.

 //

 //    Support:

 //      1. Not all specializations are supplied

 //

 //      2. Use of specializations that are not supplied will cause a

 //      compile-time error

 //

 //      3. Users are free to specialize numeric_traits for any type.

 //

 //      4. Right now, specializations are only supplied for integer types.

 //

 //      5. On implementations which do not supply compile-time constants in

 //      std::numeric_limits<>, only specializations for built-in integer types

 //      are supplied.

 //

 //      6. Handling of numbers whose range of representation is at least as

 //      great as boost::intmax_t can cause some differences to be

 //      unrepresentable in difference_type:

 //

 //        Number    difference_type

 //        ------    ---------------

 //        signed    Number

 //        unsigned  intmax_t

 //

 // template <class Number> typename numeric_traits<Number>::difference_type

 // numeric_distance(Number x, Number y)

 //    computes (y - x), attempting to avoid overflows.

 //

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

 // Revision History

 // 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams)

 // 11 Feb 2001 - Rolled back ineffective Borland-specific code

 //               (David Abrahams)

 // 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but

 //               not seeing any improvement yet (David Abrahams)

 // 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp

 //               (David Abrahams)

 // 23 Jan 2001 - Fixed logic of difference_type selection, which was

 //               completely wack. In the process, added digit_traits<>

 //               to compute the number of digits in intmax_t even when

 //               not supplied by numeric_limits<>. (David Abrahams)

 // 21 Jan 2001 - Created (David Abrahams)

 #ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901

 # define BOOST_NUMERIC_TRAITS_HPP_DWA20001901

 # include <boost/config.hpp>

 # include <boost/cstdint.hpp>

 # include <boost/static_assert.hpp>

 # include <boost/type_traits.hpp>

 # include <boost/detail/select_type.hpp>

 # include <boost/limits.hpp>

 namespace boost { namespace detail {

   // Template class is_signed -- determine whether a numeric type is signed

   // Requires that T is constructable from the literals -1 and 0.  Compile-time

   // error results if that requirement is not met (and thus signedness is not

   // likely to have meaning for that type).

   template <class Number>

   struct is_signed

   {

 #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300

     BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0)));

 #else

     BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed);

 #endif

   };

 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS

   // digit_traits - compute the number of digits in a built-in integer

   // type. Needed for implementations on which numeric_limits is not specialized

   // for intmax_t (e.g. VC6).

   template <bool is_specialized> struct digit_traits_select;

   // numeric_limits is specialized; just select that version of digits

   template <> struct digit_traits_select<true>

   {

       template <class T> struct traits

       {

           BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);

       };

   };

   // numeric_limits is not specialized; compute digits from sizeof(T)

   template <> struct digit_traits_select<false>

   {

       template <class T> struct traits

       {

           BOOST_STATIC_CONSTANT(int, digits = (

               sizeof(T) * std::numeric_limits<unsigned char>::digits

               - (is_signed<T>::value ? 1 : 0))

               );

       };

   };

   // here's the "usable" template

   template <class T> struct digit_traits

   {

       typedef digit_traits_select<

                 ::std::numeric_limits<T>::is_specialized> selector;

       typedef typename selector::template traits<T> traits;

       BOOST_STATIC_CONSTANT(int, digits = traits::digits);

   };

 #endif

   // Template class integer_traits<Integer> -- traits of various integer types

   // This should probably be rolled into boost::integer_traits one day, but I

   // need it to work without <limits>

   template <class Integer>

   struct integer_traits

   {

 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS

    private:

       typedef Integer integer_type;

       typedef std::numeric_limits<integer_type> x;

 #   if defined(BOOST_MSVC) && BOOST_MSVC <= 1300

       // for some reason, MSVC asserts when it shouldn't unless we make these

       // local definitions

       BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer);

       BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized);

       BOOST_STATIC_ASSERT(is_integer);

       BOOST_STATIC_ASSERT(is_specialized);

 #   endif

    public:

       typedef typename

       if_true<(int(x::is_signed)

               && (!int(x::is_bounded)

                  // digits is the number of no-sign bits

                   || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then<

         Integer,

       typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<

         signed int,

       typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then<

         signed long,

    // else

         intmax_t

       >::type>::type>::type difference_type;

 #else

       BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value);

       typedef typename

       if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then<

         typename if_true<(is_signed<Integer>::value)>::template then<

           Integer,

           intmax_t

         >::type,

         typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<

           std::ptrdiff_t,

           intmax_t

         >::type

       >::type difference_type;

 # endif

   };

   // Right now, only supports integers, but should be expanded.

   template <class Number>

   struct numeric_traits

   {

       typedef typename integer_traits<Number>::difference_type difference_type;

   };

   template <class Number>

   typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)

   {

       typedef typename numeric_traits<Number>::difference_type difference_type;

       return difference_type(y) - difference_type(x);

   }

 }}

 #endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901