// (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 |