feedc0de/boost_detail
1
0
Fork 0
forked from boostorg/detail
Code Pull Requests Activity

Actualized numeric_traits implementation.

Browse Source 
1. Ported to Boost.TypeTraits primitives for type inspection and simple
   metaprogramming instead of local implementations. This effectively
   drops any workarounds for compilers without support for partial template
   specializations. Such compilers are long outdated.

2. Include more fine-grained headers from Boost.TypeTraits to optimize
   compilation times.

3. Made numeric_distance function constexpr.

4. Updated the test accordingly (i.e. replaced the use of now removed local
   components with Boost.TypeTraits). Also replaced lexical_cast with
   standard streams to further reduce dependencies.

None of these changes should affect functionality.
This commit is contained in:
Andrey Semashev
2017-09-20 02:01:51 +03:00
parent 9b2065c0ca
commit 15d8f9a59c
2 changed files with 98 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
include/boost/detail/numeric_traits.hpp
View File

@ -58,64 +58,38 @@
#ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901
#define BOOST_NUMERIC_TRAITS_HPP_DWA20001901
#include <cstddef>
#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>
#include <boost/cstdint.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/conditional.hpp>
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_integral.hpp>
#endif
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)
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
// for some integer types, like __int128 in libstdc++ (gcc).
template <class T, bool IsSpecialized = std::numeric_limits<T>::is_specialized>
struct digit_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
template <class T>
struct digit_traits<T, false>
{
BOOST_STATIC_CONSTANT(int, digits = (
sizeof(T) * std::numeric_limits<unsigned char>::digits
- (is_signed<T>::value ? 1 : 0))
- (boost::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
@ -129,38 +103,42 @@ namespace boost { namespace detail {
typedef Integer integer_type;
typedef std::numeric_limits<integer_type> x;
public:
typedef typename
if_true<(int(x::is_signed)
typedef typename boost::conditional<
(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<
|| (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits))),
Integer,
typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<
typename boost::conditional<
(int(x::digits) + 1 < digit_traits<signed int>::digits),
signed int,
typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then<
typename boost::conditional<
(int(x::digits) + 1 < digit_traits<signed long>::digits),
signed long,
// else
intmax_t
>::type>::type>::type difference_type;
boost::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<
typedef typename boost::conditional<
(sizeof(Integer) >= sizeof(intmax_t)),
typename if_true<(is_signed<Integer>::value)>::template then<
boost::conditional<
(boost::is_signed<Integer>::value),
Integer,
intmax_t
>::type,
boost::intmax_t
>,
typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<
boost::conditional<
(sizeof(Integer) < sizeof(std::ptrdiff_t)),
std::ptrdiff_t,
intmax_t
>::type
>::type difference_type;
boost::intmax_t
>
>::type::type difference_type;
#endif
};
@ -172,7 +150,7 @@ namespace boost { namespace detail {
};
template <class Number>
typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
inline BOOST_CONSTEXPR 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);

56
test/numeric_traits_test.cpp
View File

@ -17,14 +17,15 @@
#include <boost/detail/numeric_traits.hpp>
#include <cassert>
#include <boost/type_traits.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/utility.hpp>
#include <boost/lexical_cast.hpp>
#include <climits>
#include <typeinfo>
#include <iostream>
#include <sstream>
#include <string>
#ifndef BOOST_NO_LIMITS
#include <limits>
@ -109,7 +110,7 @@ struct complement<1>
template <class Number>
struct traits
{
BOOST_STATIC_CONSTANT(bool, is_signed = boost::detail::is_signed<Number>::value);
BOOST_STATIC_CONSTANT(bool, is_signed = boost::is_signed<Number>::value);
BOOST_STATIC_CONSTANT(Number, min =
complement_base<is_signed>::template values<Number>::min);
BOOST_STATIC_CONSTANT(Number, max =
@ -184,21 +185,30 @@ template <> struct promote<boost::uintmax_t> {
std::string static from(const boost::uintmax_t x) {
if (x > ULONG_MAX)
return std::string("large unsigned value");
else
return boost::lexical_cast<std::string>((unsigned long)x);
else {
std::ostringstream strm;
strm << (unsigned long)x;
return strm.str();
}
}
};
template <> struct promote<boost::intmax_t> {
std::string static from(const boost::intmax_t x) {
if (x > boost::intmax_t(ULONG_MAX))
return std::string("large positive signed value");
else if (x >= 0)
return boost::lexical_cast<std::string>((unsigned long)x);
else if (x >= 0) {
std::ostringstream strm;
strm << (unsigned long)x;
return strm.str();
}
if (x < boost::intmax_t(LONG_MIN))
return std::string("large negative signed value");
else
return boost::lexical_cast<std::string>((long)x);
else {
std::ostringstream strm;
strm << (long)x;
return strm.str();
}
}
};
#endif
@ -225,7 +235,7 @@ template <class Number>
void test_aux(unsigned_tag, Number*)
{
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
BOOST_STATIC_ASSERT(!boost::is_signed<Number>::value);
BOOST_STATIC_ASSERT(
(sizeof(Number) < sizeof(boost::intmax_t))
| (boost::is_same<difference_type, boost::intmax_t>::value));
@ -272,7 +282,7 @@ struct in_range_tag {};
template <class Number>
void signed_test(in_range_tag, Number*)
{
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
const Number max = complement_traits<Number>::max;
const Number min = complement_traits<Number>::min;
@ -293,7 +303,7 @@ void signed_test(in_range_tag, Number*)
template <class Number>
void signed_test(out_of_range_tag, Number*)
{
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
const Number max = complement_traits<Number>::max;
const Number min = complement_traits<Number>::min;
@ -318,7 +328,7 @@ template <class Number>
void test_aux(signed_tag, Number*)
{
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
BOOST_STATIC_ASSERT(
(sizeof(Number) < sizeof(boost::intmax_t))
| (boost::is_same<difference_type, Number>::value));
@ -340,13 +350,11 @@ void test_aux(signed_tag, Number*)
std::cout << "difference_type = " << typeid(difference_type).name() << "..."
<< std::flush;
typedef typename boost::detail::if_true<
(sizeof(Number) < sizeof(boost::intmax_t))>
::template then<
typedef typename boost::conditional<
(sizeof(Number) < sizeof(boost::intmax_t)),
in_range_tag,
out_of_range_tag
>::type
range_tag;
>::type range_tag;
signed_test<Number>(range_tag(), 0);
}
@ -365,7 +373,7 @@ void test(Number* = 0)
<< "..." << std::flush;
// factoring out difference_type for the assert below confused Borland :(
typedef boost::detail::is_signed<
typedef boost::is_signed<
#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
typename
#endif
@ -373,9 +381,11 @@ void test(Number* = 0)
> is_signed;
BOOST_STATIC_ASSERT(is_signed::value);
typedef typename boost::detail::if_true<
boost::detail::is_signed<Number>::value
>::template then<signed_tag, unsigned_tag>::type signedness;
typedef typename boost::conditional<
boost::is_signed<Number>::value,
signed_tag,
unsigned_tag
>::type signedness;
test_aux<Number>(signedness(), 0);
std::cout << "passed" << std::endl;