From f27ad7b337585d4c2467dd32cc37ffcc04662637 Mon Sep 17 00:00:00 2001
From: Daryle Walker
Date: Tue, 15 Jul 2008 18:56:59 +0000
Subject: [PATCH] Added MPL-compatible variant of the processor-optimized
integer template
[SVN r47452]
---
include/boost/integer.hpp | 25 ++++++++++++-----
include/boost/integer_fwd.hpp | 3 +++
integer.htm | 51 +++++++++++++++++++++--------------
test/integer_test.cpp | 19 ++++++++-----
4 files changed, 66 insertions(+), 32 deletions(-)
diff --git a/include/boost/integer.hpp b/include/boost/integer.hpp
index a976e3b..3f5c3b4 100644
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@@ -7,7 +7,8 @@
// See http://www.boost.org/libs/integer for documentation.
// Revision History
-// 15 Jul 08 Added exact-integer templates. (Daryle Walker)
+// 15 Jul 08 Added exact-integer templates; added MPL-compatible variant of
+// processor-optimized integer template. (Daryle Walker)
// 14 Jul 08 Added extended-integer support. (Daryle Walker)
// 13 Jul 08 Redid implmentation. (Daryle Walker)
// 22 Sep 01 Added value-based integer templates. (Daryle Walker)
@@ -20,10 +21,11 @@
#include // self include
-#include // for BOOST_STATIC_CONSTANT, etc.
-#include // for boost::uintmax_t, intmax_t
-#include // for boost::integer_traits
-#include // for std::numeric_limits
+#include // for BOOST_STATIC_CONSTANT, etc.
+#include // for boost::uintmax_t, intmax_t
+#include // for boost::integer_traits
+#include // for std::numeric_limits
+#include // for boost::enable_if_c
#include // for UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, etc.
@@ -32,10 +34,21 @@ namespace boost
// integer template mapping a type to its processor-optimized analog -----//
+ // Some types can be handled better by the processor than others. This
+ // template metafunction should map various built-in integral types to
+ // the processor's perferred type for the given type's value range
+ template < typename BaseInt >
+ struct fast_integral
+ {
+ typedef BaseInt type;
+ };
+
+ // Platform-specific specializations should go here.
+
// fast integers from least integers
// int_fast_t<> works correctly for unsigned too, in spite of the name.
template< typename LeastInt >
- struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
+ struct int_fast_t { typedef typename fast_integral::type fast; };
namespace detail
{
diff --git a/include/boost/integer_fwd.hpp b/include/boost/integer_fwd.hpp
index 01b9d2a..90102e8 100644
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@@ -84,6 +84,9 @@ template < >
// From ------------------------------------------------//
+template < typename BaseInt >
+ struct fast_integral;
+
template < typename LeastInt >
struct int_fast_t;
diff --git a/integer.htm b/integer.htm
index 0743ed4..6627935 100644
--- a/integer.htm
+++ b/integer.htm
@@ -40,10 +40,27 @@ is particularly useful for solving generic programming problems.
namespace boost
{
// fast integers from least integers
+ template< typename BaseInt >
+ struct fast_integral
+ {
+ typedef implementation_supplied type;
+ };
+
template< typename LeastInt >
struct int_fast_t
{
- typedef implementation_supplied fast;
+ typedef typename fast_integral<LeastInt>::type fast;
+ };
+
+ // MPL-compatible
+ template< int Bits, typename Signedness >
+ struct exact_integral
+ {
+ static bool const is_specialized = implementation_supplied;
+ static bool const is_signed = implementation_supplied;
+ static int const bit_count = Bits;
+
+ typedef implementation_supplied type;
};
// signed
@@ -57,7 +74,7 @@ namespace boost
template< int Bits >
struct int_exact_t
{
- typedef implementation_supplied exact;
+ typedef typename exact_integral<Bits, signed>::type exact;
};
// unsigned
@@ -71,7 +88,7 @@ namespace boost
template< int Bits >
struct uint_exact_t
{
- typedef implementation_supplied exact;
+ typedef typename exact_integral<Bits, unsigned>::type exact;
};
// signed
@@ -96,31 +113,25 @@ namespace boost
typedef implementation_supplied least;
typedef int_fast_t<least>::fast fast;
};
-
- // MPL-compatible
- template< int Bits, typename Signedness >
- struct exact_integral
- {
- static bool const is_specialized = implementation_supplied;
- static bool const is_signed = implementation_supplied;
- static int const bit_count = Bits;
-
- typedef implementation_supplied type;
- };
} // namespace boost
-The int_fast_t
class template maps its input type to the
+
The fast_integral
class template maps its input type to the
next-largest type that the processor can manipulate the easiest, or to
itself if the input type is already an easy-to-manipulate type. For
instance, processing a bunch of char
objects may go faster
if they were converted to int
objects before processing.
-The input type, passed as the only template parameter, must be a
-built-in integral type, except bool
. Unsigned integral
-types can be used, as well as signed integral types, despite the name.
-The output type is given as the class member fast
.
+The input type, passed as the only template parameter, can be any built-in
+integral type besides bool
. The output type is given as the class
+member type
.
+
+The int_fast_t
class template is the classic meta-function for
+this operation. Despite the name, it works for unsigned integral types just
+like it works for the signed integral types. The output type is given as the
+class member fast
, defined to be the same as the corresponding
+result from the fast_integral
meta-function.
Implementation Notes
By default, the output type is identical to the input type. Eventually,
@@ -282,7 +293,7 @@ struct name
type |
is_specialized == true |
The meta-function's result. It appears only if the input parameters
- satisfy the template's requirements. It's presence, or lack thereof,
+ satisfy the template's requirements. Its presence, or lack thereof,
enables "Substitution Failure Is Not An Error" (SFINAE)
techniques, instead of a hard compiler diagnostic. |
diff --git a/test/integer_test.cpp b/test/integer_test.cpp
index ee7bf42..49cfb59 100644
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@@ -8,7 +8,8 @@
// See http://www.boost.org/libs/integer for documentation.
// Revision History
-// 15 Jul 08 Added exact-integer templates. (Daryle Walker)
+// 15 Jul 08 Added exact-integer templates; added MPL-compatible variant of
+// processor-optimized integer template. (Daryle Walker)
// 14 Jul 08 Improved testing of processor-optimized integer template; added
// extended-integer support. (Daryle Walker)
// 13 Jul 08 Modernized tests w/ MPL instead of giant macros (Daryle Walker)
@@ -69,15 +70,15 @@
// If specializations have not already been done, then we can confirm
-// the effects of the "fast" types by making a specialization. If there
+// the effects of the fast types by making a specialization. If there
// is a specialization for "short," make sure that CONTROL_FAST_SHORT
// is set to a type distinct from "short" and the default implementation.
namespace boost
{
template < >
- struct int_fast_t< short >
+ struct fast_integral< short >
{
- typedef CONTROL_FAST_SHORT fast;
+ typedef CONTROL_FAST_SHORT type;
};
}
@@ -273,8 +274,10 @@ BOOST_AUTO_TEST_CASE( fast_type_test )
{
#ifndef BOOST_NO_USING_TEMPLATE
using std::numeric_limits;
+ using boost::is_same;
#else
using namespace std;
+ using namespace boost;
#endif
typedef short least_type;
@@ -282,8 +285,12 @@ BOOST_AUTO_TEST_CASE( fast_type_test )
typedef numeric_limits least_limits;
typedef numeric_limits fast_limits;
- BOOST_MPL_ASSERT_RELATION( (boost::is_same::value),
- ==, false );
+ typedef boost::fast_integral::type real_fast_type;
+
+ BOOST_MPL_ASSERT_RELATION( (is_same::value), ==,
+ false );
+ BOOST_MPL_ASSERT_RELATION( (is_same::value), ==,
+ true );
BOOST_MPL_ASSERT_RELATION( fast_limits::is_specialized, ==, true );
BOOST_MPL_ASSERT_RELATION( fast_limits::is_signed &&
fast_limits::is_bounded, ==, true );