feedc0de/boost_type_traits
1
0
Fork 0
forked from boostorg/type_traits
Code Pull Requests Activity

Pick up missing smart_ptr, utility, and type_traits files from full merge from trunk at revision 41356 of entire boost-root tree.

Browse Source 
[SVN r41386]
This commit is contained in:
Beman Dawes
2007-11-25 22:34:55 +00:00
parent 2d9de2e57e
commit 0265a9354b
87 changed files with 4940 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
doc/add_const.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:add_const add_const]
template <class T>
struct add_const
{
typedef __below type;
};
__type The same type as `T const` for all `T`.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/add_const.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`add_const<int>::type`][`int const`]]
[[`add_const<int&>::type`] [`int&`]]
[[`add_const<int*>::type`] [`int* const`]]
[[`add_const<int const>::type`] [`int const`]]
]
[endsect]

41
doc/add_cv.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:add_cv add_cv]
template <class T>
struct add_cv
{
typedef __below type;
};
__type The same type as `T const volatile` for all `T`.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/add_cv.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`add_cv<int>::type`][`int const volatile`]]
[[`add_cv<int&>::type`] [`int&`]]
[[`add_cv<int*>::type`] [`int* const volatile`]]
[[`add_cv<int const>::type`] [`int const volatile`]]
]
[endsect]

45
doc/add_pointer.qbk Normal file
View File

@@ -0,0 +1,45 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:add_pointer add_pointer]
template <class T>
struct add_pointer
{
typedef __below type;
};
__type The same type as `remove_reference<T>::type*`.
The rationale for this template
is that it produces the same type as `TYPEOF(&t)`,
where `t` is an object of type `T`.
__std_ref 8.3.1.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`add_pointer<int>::type`][`int*`]]
[[`add_pointer<int const&>::type`] [`int const*`]]
[[`add_pointer<int*>::type`] [`int**`]]
[[`add_pointer<int*&>::type`] [`int**`]]
]
[endsect]

41
doc/add_reference.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:add_reference add_reference]
template <class T>
struct add_reference
{
typedef __below type;
};
__type If `T` is not a reference type then `T&`, otherwise `T`.
__std_ref 8.3.2.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`add_reference<int>::type`][`int&`]]
[[`add_reference<int const&>::type`] [`int const&`]]
[[`add_reference<int*>::type`] [`int*&`]]
[[`add_reference<int*&>::type`] [`int*&`]]
]
[endsect]

41
doc/add_volatile.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:add_volatile add_volatile]
template <class T>
struct add_volatile
{
typedef __below type;
};
__type The same type as `T volatile` for all `T`.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`add_volatile<int>::type`][`int volatile`]]
[[`add_volatile<int&>::type`] [`int&`]]
[[`add_volatile<int*>::type`] [`int* volatile`]]
[[`add_volatile<int const>::type`] [`int const volatile`]]
]
[endsect]

22
doc/aligned_storage.qbk Normal file
View File

@@ -0,0 +1,22 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:aligned_storage aligned_storage]
template <std::size_t Size, std::size_t Align>
struct aligned_storage
{
typedef __below type;
};
__type a built-in or POD type with size `Size` and an alignment
that is a multiple of `Align`.
__header ` #include <boost/type_traits/aligned_storage.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

34
doc/alignment_of.qbk Normal file
View File

@@ -0,0 +1,34 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:alignment_of alignment_of]
template <class T>
struct alignment_of : public __integral_constant<std::size_t, ALIGNOF(T)> {};
__inherit Class template alignment_of inherits from
`__integral_constant<std::size_t, ALIGNOF(T)>`, where `ALIGNOF(T)` is the
alignment of type T.
['Note: strictly speaking you should only rely on
the value of `ALIGNOF(T)` being a multiple of the true alignment of T, although
in practice it does compute the correct value in all the cases we know about.]
__header ` #include <boost/type_traits/alignment_of.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`alignment_of<int>` inherits from `__integral_constant<std::size_t, ALIGNOF(int)>`.]
[:`alignment_of<char>::type` is the type `__integral_constant<std::size_t, ALIGNOF(char)>`.]
[:`alignment_of<double>::value` is an integral constant
expression with value `ALIGNOF(double)`.]
[:`alignment_of<T>::value_type` is the type `std::size_t`.]
[endsect]

24
doc/alignment_traits.qbk Normal file
View File

@@ -0,0 +1,24 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:alignment Synthesizing Types with Specific Alignments]
Some low level memory management routines need to synthesize a POD type with
specific alignment properties. The template `__type_with_alignment` finds the smallest
type with a specified alignment, while template `__aligned_storage` creates a type
with a specific size and alignment.
[*Synopsis]
template <std::size_t Align>
struct __type_with_alignment;
template <std::size_t Size, std::size_t Align>
struct __aligned_storage;
[endsect]

322
doc/background.qbk Normal file
View File

@@ -0,0 +1,322 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:background Background and Tutorial]
The following is an updated version of the article "C++ Type traits"
by John Maddock and Steve Cleary that appeared in the October 2000
issue of [@http://www.ddj.com Dr Dobb's Journal].
Generic programming (writing code which works with any data type meeting a
set of requirements) has become the method of choice for providing reusable code.
However, there are times in generic programming when "generic" just isn't
good enough - sometimes the differences between types are too large for an
efficient generic implementation. This is when the traits technique
becomes important - by encapsulating those properties that need to be
considered on a type by type basis inside a traits class, we can
minimize the amount of code that has to differ from one type to another,
and maximize the amount of generic code.
Consider an example: when working with character strings, one common operation is
to determine the length of a null terminated string. Clearly it's possible to
write generic code that can do this, but it turns out that there are much more
efficient methods available: for example, the C library functions `strlen` and
`wcslen` are usually written in assembler, and with suitable hardware support
can be considerably faster than a generic version written in C++.
The authors of the C++ standard library realized this, and abstracted the
properties of `char` and `wchar_t` into the class `char_traits`. Generic code
that works with character strings can simply use `char_traits<>::length` to
determine the length of a null terminated string, safe in the knowledge
that specializations of `char_traits` will use the most appropriate method
available to them.
[h4 Type Traits]
Class `char_traits` is a classic example of a collection of type specific
properties wrapped up in a single class - what Nathan Myers termed a
/baggage class/[link background.references \[1\]]. In the Boost type-traits library, we[link background.references \[2\]] have written a
set of very specific traits classes, each of which encapsulate a single trait
from the C++ type system; for example, is a type a pointer or a reference type?
Or does a type have a trivial constructor, or a const-qualifier?
The type-traits classes share a unified design: each class inherits from a
the type __true_type if the type has the specified property and inherits from
__false_type otherwise. As we will show, these classes can be used in
generic programming to determine the properties of a given type and introduce
optimizations that are appropriate for that case.
The type-traits library also contains a set of classes that perform a
specific transformation on a type; for example, they can remove a
top-level const or volatile qualifier from a type. Each class that
performs a transformation defines a single typedef-member `type`
that is the result of the transformation. All of the type-traits
classes are defined inside namespace `boost`; for brevity, namespace-qualification
is omitted in most of the code samples given.
[h4 Implementation]
There are far too many separate classes contained in the type-traits library
to give a full implementation here - see the source code in the Boost library
for the full details - however, most of the implementation is fairly repetitive
anyway, so here we will just give you a flavor for how some of the classes are
implemented. Beginning with possibly the simplest class in the library,
`is_void<T>` inherits from `__true_type` only if `T` is `void`.
template <typename T>
struct __is_void : public __false_type{};
template <>
struct __is_void<void> : public __true_type{};
Here we define a primary version of the template class `__is_void`, and
provide a full-specialization when `T` is `void`. While full specialization
of a template class is an important technique, sometimes we need a
solution that is halfway between a fully generic solution, and a full
specialization. This is exactly the situation for which the standards committee
defined partial template-class specialization. As an example, consider the
class `boost::is_pointer<T>`: here we needed a primary version that handles
all the cases where T is not a pointer, and a partial specialization to
handle all the cases where T is a pointer:
template <typename T>
struct __is_pointer : public __false_type{};
template <typename T>
struct __is_pointer<T*> : public __true_type{};
The syntax for partial specialization is somewhat arcane and could easily
occupy an article in its own right; like full specialization, in order to
write a partial specialization for a class, you must first declare the
primary template. The partial specialization contains an extra <...> after the
class name that contains the partial specialization parameters; these define
the types that will bind to that partial specialization rather than the
default template. The rules for what can appear in a partial specialization
are somewhat convoluted, but as a rule of thumb if you can legally write two
function overloads of the form:
void foo(T);
void foo(U);
Then you can also write a partial specialization of the form:
template <typename T>
class c{ /*details*/ };
template <typename T>
class c<U>{ /*details*/ };
This rule is by no means foolproof, but it is reasonably simple to remember
and close enough to the actual rule to be useful for everyday use.
As a more complex example of partial specialization consider the class
`remove_extent<T>`. This class defines a single typedef-member `type` that
is the same type as T but with any top-level array bounds removed;
this is an example of a traits class that performs a transformation on a type:
template <typename T>
struct __remove_extent
{ typedef T type; };
template <typename T, std::size_t N>
struct __remove_extent<T[N]>
{ typedef T type; };
The aim of `__remove_extent` is this: imagine a generic algorithm that is
passed an array type as a template parameter, `__remove_extent` provides a
means of determining the underlying type of the array. For example
`remove_extent<int[4][5]>::type` would evaluate to the type `int[5]`.
This example also shows that the number of template parameters in a
partial specialization does not have to match the number in the
default template. However, the number of parameters that appear after the
class name do have to match the number and type of the parameters in the
default template.
[h4 Optimized copy]
As an example of how the type traits classes can be used, consider the
standard library algorithm copy:
template<typename Iter1, typename Iter2>
Iter2 copy(Iter1 first, Iter1 last, Iter2 out);
Obviously, there's no problem writing a generic version of copy that works
for all iterator types `Iter1` and `Iter2`; however, there are some
circumstances when the copy operation can best be performed by a call to
`memcpy`. In order to implement copy in terms of `memcpy` all of the
following conditions need to be met:
* Both of the iterator types `Iter1` and `Iter2` must be pointers.
* Both `Iter1` and `Iter2` must point to the same type - excluding const and
volatile-qualifiers.
* The type pointed to by `Iter1` must have a trivial assignment operator.
By trivial assignment operator we mean that the type is either a scalar type[link background.references \[3\]] or:
* The type has no user defined assignment operator.
* The type does not have any data members that are references.
* All base classes, and all data member objects must have trivial assignment operators.
If all these conditions are met then a type can be copied using `memcpy`
rather than using a compiler generated assignment operator. The type-traits
library provides a class `__has_trivial_assign`, such that
`has_trivial_assign<T>::value` is true only if T has a trivial assignment operator.
This class "just works" for scalar types, but has to be explicitly
specialised for class/struct types that also happen to have a trivial assignment
operator. In other words if __has_trivial_assign gives the wrong answer,
it will give the "safe" wrong answer - that trivial assignment is not allowable.
The code for an optimized version of copy that uses `memcpy` where appropriate is
given in [link boost_typetraits.examples.copy the examples]. The code begins by defining a template
function `do_copy` that performs a "slow but safe" copy. The last parameter passed
to this function may be either a `__true_type` or a `__false_type`. Following that
there is an overload of do_copy that uses `memcpy`: this time the iterators are required
to actually be pointers to the same type, and the final parameter must be a
`__true_type`. Finally, the version of `copy` calls `do_copy`, passing
`__has_trivial_assign<value_type>()` as the final parameter: this will dispatch
to the optimized version where appropriate, otherwise it will call the
"slow but safe version".
[h4 Was it worth it?]
It has often been repeated in these columns that "premature optimization is the
root of all evil" [link background.references \[4\]]. So the question must be asked: was our optimization
premature? To put this in perspective the timings for our version of copy
compared a conventional generic copy[link background.references \[5\]] are shown in table 1.
Clearly the optimization makes a difference in this case; but, to be fair,
the timings are loaded to exclude cache miss effects - without this
accurate comparison between algorithms becomes difficult. However, perhaps
we can add a couple of caveats to the premature optimization rule:
*If you use the right algorithm for the job in the first place then optimization
will not be required; in some cases, memcpy is the right algorithm.
*If a component is going to be reused in many places by many people then
optimizations may well be worthwhile where they would not be so for a single
case - in other words, the likelihood that the optimization will be
absolutely necessary somewhere, sometime is that much higher.
Just as importantly the perceived value of the stock implementation will be
higher: there is no point standardizing an algorithm if users reject it on
the grounds that there are better, more heavily optimized versions available.
[table Time taken to copy 1000 elements using `copy<const T*, T*>` (times in micro-seconds)
[[Version] [T] [Time]]
[["Optimized" copy] [char] [0.99]]
[[Conventional copy] [char] [8.07]]
[["Optimized" copy] [int] [2.52]]
[[Conventional copy] [int] [8.02]]
]
[h4 Pair of References]
The optimized copy example shows how type traits may be used to perform
optimization decisions at compile-time. Another important usage of type traits
is to allow code to compile that otherwise would not do so unless excessive
partial specialization is used. This is possible by delegating partial
specialization to the type traits classes. Our example for this form of
usage is a pair that can hold references [link background.references \[6\]].
First, let us examine the definition of `std::pair`, omitting the
comparison operators, default constructor, and template copy constructor for
simplicity:
template <typename T1, typename T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(const T1 & nfirst, const T2 & nsecond)
:first(nfirst), second(nsecond) { }
};
Now, this "pair" cannot hold references as it currently stands, because the
constructor would require taking a reference to a reference, which is
currently illegal [link background.references \[7\]]. Let us consider what the constructor's parameters
would have to be in order to allow "pair" to hold non-reference types,
references, and constant references:
[table Required Constructor Argument Types
[[Type of `T1`] [Type of parameter to initializing constructor]]
[[T] [const T &]]
[[T &] [T &]]
[[const T &] [const T &]]
]
A little familiarity with the type traits classes allows us to construct a
single mapping that allows us to determine the type of parameter from the
type of the contained class. The type traits classes provide a
transformation __add_reference, which adds a reference to its type,
unless it is already a reference.
[table Using add_reference to synthesize the correct constructor type
[[Type of `T1`] [Type of `const T1`] [Type of `add_reference<const T1>::type`]]
[[T] [const T] [const T &]]
[[T &] [T & \[8\]] [T &]]
[[const T &] [const T &] [const T &]]
]
This allows us to build a primary template definition for `pair` that can
contain non-reference types, reference types, and constant reference types:
template <typename T1, typename T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(boost::__add_reference<const T1>::type nfirst,
boost::__add_reference<const T2>::type nsecond)
:first(nfirst), second(nsecond) { }
};
Add back in the standard comparison operators, default constructor,
and template copy constructor (which are all the same), and you have a
`std::pair` that can hold reference types!
This same extension could have been done using partial template specialization
of `pair`, but to specialize `pair` in this way would require three partial
specializations, plus the primary template. Type traits allows us to
define a single primary template that adjusts itself auto-magically to
any of these partial specializations, instead of a brute-force partial
specialization approach. Using type traits in this fashion allows
programmers to delegate partial specialization to the type traits classes,
resulting in code that is easier to maintain and easier to understand.
[h4 Conclusion]
We hope that in this article we have been able to give you some idea of
what type-traits are all about. A more complete listing of the available
classes are in the boost documentation, along with further examples using
type traits. Templates have enabled C++ uses to take the advantage of the
code reuse that generic programming brings; hopefully this article has
shown that generic programming does not have to sink to the lowest common
denominator, and that templates can be optimal as well as generic.
[h4 Acknowledgements]
The authors would like to thank Beman Dawes and Howard Hinnant for their
helpful comments when preparing this article.
[h4 [#background.references]References]
# Nathan C. Myers, C++ Report, June 1995.
# The type traits library is based upon contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.
# A scalar type is an arithmetic type (i.e. a built-in integer or floating point type), an enumeration type, a pointer, a pointer to member, or a const- or volatile-qualified version of one of these types.
# This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg 268.
# The test code is available as part of the boost utility library (see algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all optimisations turned on, tests were conducted on a 400MHz Pentium II machine running Microsoft Windows 98.
# John Maddock and Howard Hinnant have submitted a "compressed_pair" library to Boost, which uses a technique similar to the one described here to hold references. Their pair also uses type traits to determine if any of the types are empty, and will derive instead of contain to conserve space -- hence the name "compressed".
# This is actually an issue with the C++ Core Language Working Group (issue #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow a "reference to a reference to T" to mean the same thing as a "reference to T", but only in template instantiation, in a method similar to multiple cv-qualifiers.
# For those of you who are wondering why this shouldn't be const-qualified, remember that references are always implicitly constant (for example, you can't re-assign a reference). Remember also that "const T &" is something completely different. For this reason, cv-qualifiers on template type arguments that are references are ignored.
[endsect]

41
doc/credits.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:credits Credits]
This documentation was pulled together by John Maddock, using
[@../../tools/quickbook/doc/html/index.html Boost.Quickbook]
and [@boostbook.html Boost.DocBook].
The original version of this library was created by Steve Cleary,
Beman Dawes, Howard Hinnant, and John Maddock. John Maddock is the
current maintainer of the library.
This version of type traits library is based on contributions by
Adobe Systems Inc, David Abrahams, Steve Cleary,
Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus,
Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek.
Mat Marcus and Jesse Jones invented, and
[@http://opensource.adobe.com/project4/project.shtml published a paper describing],
the partial specialization workarounds used in this library.
Aleksey Gurtovoy added MPL integration to the library.
The __is_convertible template is based on code originally devised by
Andrei Alexandrescu, see
"[@http://www.cuj.com/experts/1810/alexandr.htm?topic=experts
Generic<Programming>: Mappings between Types and Values]".
The latest version of this library and documentation can be found at
[@http://www.boost.org www.boost.org]. Bugs, suggestions and discussion
should be directed to boost@lists.boost.org
(see [@http://www.boost.org/more/mailing_lists.htm#main
www.boost.org/more/mailing_lists.htm#main] for subscription details).
[endsect]

40
doc/decay.qbk Normal file
View File

@@ -0,0 +1,40 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:decay decay]
template <class T>
struct decay
{
typedef __below type;
};
__type Let `U` be the result of `remove_reference<T>::type`, then if `U` is
an array type, the result is `remove_extent<U>*`, otherwise if `U` is a
function type then the result is `U*`, otherwise the result is `U`.
__std_ref 3.9.1.
__header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`decay<int[2][3]>::type`][`int[2]*`]]
[[`decay<int(&)[2]>::type`] [`int*`]]
[[`decay<int(&)(double)>::type`] [`int(*)(double)`]]
[[`int(*)(double`] [`int(*)(double)`]]
[[`int(double)`] [`int(*)(double)`]]
]
[endsect]

20
doc/decomposing_func.qbk Normal file
View File

@@ -0,0 +1,20 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:function Decomposing Function Types]
The class template __function_traits extracts information from function types
(see also __is_function). This traits class allows you to tell how many arguments
a function takes, what those argument types are, and what the return type is.
[*Synopsis]
template <std::size_t Align>
struct __function_traits;
[endsect]

219
doc/examples.qbk Normal file
View File

@@ -0,0 +1,219 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:examples Examples]
[section:copy An Optimized Version of std::copy]
Demonstrates a version of `std::copy` that uses `__has_trivial_assign` to
determine whether to use `memcpy` to optimise the copy operation
(see [@../../libs/type_traits/examples/copy_example.cpp copy_example.cpp]):
//
// opt::copy
// same semantics as std::copy
// calls memcpy where appropriate.
//
namespace detail{
template<typename I1, typename I2, bool b>
I2 copy_imp(I1 first, I1 last, I2 out, const boost::__integral_constant<bool, b>&)
{
while(first != last)
{
*out = *first;
++out;
++first;
}
return out;
}
template<typename T>
T* copy_imp(const T* first, const T* last, T* out, const boost::__true_type&)
{
memcpy(out, first, (last-first)*sizeof(T));
return out+(last-first);
}
}
template<typename I1, typename I2>
inline I2 copy(I1 first, I1 last, I2 out)
{
//
// We can copy with memcpy if T has a trivial assignment operator,
// and if the iterator arguments are actually pointers (this last
// requirement we detect with overload resolution):
//
typedef typename std::iterator_traits<I1>::value_type value_type;
return detail::copy_imp(first, last, out, boost::__has_trivial_assign<value_type>());
}
[endsect]
[section:fill An Optimised Version of std::fill]
Demonstrates a version of `std::fill` that uses `__has_trivial_assign` to
determine whether to use `memset` to optimise the fill operation
(see [@../../libs/type_traits/examples/fill_example.cpp fill_example.cpp]):
//
// fill
// same as std::fill, but uses memset where appropriate
//
namespace detail{
template <typename I, typename T, bool b>
void do_fill(I first, I last, const T& val, const boost::__integral_constant<bool, b>&)
{
while(first != last)
{
*first = val;
++first;
}
}
template <typename T>
void do_fill(T* first, T* last, const T& val, const boost::__true_type&)
{
std::memset(first, val, last-first);
}
}
template <class I, class T>
inline void fill(I first, I last, const T& val)
{
//
// We can do an optimised fill if T has a trivial assignment
// operator and if it's size is one:
//
typedef boost::__integral_constant<bool,
::boost::__has_trivial_assign<T>::value && (sizeof(T) == 1)> truth_type;
detail::do_fill(first, last, val, truth_type());
}
[endsect]
[section:destruct An Example that Omits Destructor Calls For Types with Trivial Destructors]
Demonstrates a simple algorithm that uses `__has_trivial_destruct` to
determine whether to destructors need to be called
(see [@../../libs/type_traits/examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]):
//
// algorithm destroy_array:
// The reverse of std::unitialized_copy, takes a block of
// initialized memory and calls destructors on all objects therein.
//
namespace detail{
template <class T>
void do_destroy_array(T* first, T* last, const boost::__false_type&)
{
while(first != last)
{
first->~T();
++first;
}
}
template <class T>
inline void do_destroy_array(T* first, T* last, const boost::__true_type&)
{
}
} // namespace detail
template <class T>
inline void destroy_array(T* p1, T* p2)
{
detail::do_destroy_array(p1, p2, ::boost::__has_trivial_destructor<T>());
}
[endsect]
[section:iter An improved Version of std::iter_swap]
Demonstrates a version of `std::iter_swap` that use type traits to
determine whether an it's arguments are proxying iterators or not,
if they're not then it just does a `std::swap` of it's dereferenced
arguments (the
same as `std::iter_swap` does), however if they are proxying iterators
then takes special care over the swap to ensure that the algorithm
works correctly for both proxying iterators, and even iterators of
different types
(see [@../../libs/type_traits/examples/iter_swap_example.cpp iter_swap_example.cpp]):
//
// iter_swap:
// tests whether iterator is a proxying iterator or not, and
// uses optimal form accordingly:
//
namespace detail{
template <typename I>
static void do_swap(I one, I two, const boost::__false_type&)
{
typedef typename std::iterator_traits<I>::value_type v_t;
v_t v = *one;
*one = *two;
*two = v;
}
template <typename I>
static void do_swap(I one, I two, const boost::__true_type&)
{
using std::swap;
swap(*one, *two);
}
}
template <typename I1, typename I2>
inline void iter_swap(I1 one, I2 two)
{
//
// See is both arguments are non-proxying iterators,
// and if both iterator the same type:
//
typedef typename std::iterator_traits<I1>::reference r1_t;
typedef typename std::iterator_traits<I2>::reference r2_t;
typedef boost::__integral_constant<bool,
::boost::__is_reference<r1_t>::value
&& ::boost::__is_reference<r2_t>::value
&& ::boost::__is_same<r1_t, r2_t>::value> truth_type;
detail::do_swap(one, two, truth_type());
}
[endsect]
[section:to_double Convert Numeric Types and Enums to double]
Demonstrates a conversion of
[@../../libs/numeric/conversion/doc/definitions.html#numtypes Numeric Types]
and enum types to double:
template<class T>
inline double to_double(T const& value)
{
typedef typename boost::promote<T>::type promoted;
return boost::numeric::converter<double,promoted>::convert(value);
}
[endsect]
[endsect]

41
doc/extent.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:extent extent]
template <class T, std::size_t N = 0>
struct extent : public __integral_constant<std::size_t, EXTENT(T,N)> {};
__inherit Class template extent inherits from `__integral_constant<std::size_t, EXTENT(T,N)>`,
where `EXTENT(T,N)` is the number of elements in the N'th array dimention of type `T`.
If `T` is not an array type, or if `N > __rank<T>::value`, or if the N'th array bound
is incomplete, then `EXTENT(T,N)` is zero.
__header ` #include <boost/type_traits/extent.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`extent<int[1]>` inherits from `__integral_constant<std::size_t, 1>`.]
[:`extent<double[2][3][4], 1>::type` is the type `__integral_constant<std::size_t, 3>`.]
[:`extent<int[4]>::value` is an integral constant
expression that evaluates to /4/.]
[:`extent<int[][2]>::value` is an integral constant
expression that evaluates to /0/.]
[:`extent<int[][2], 1>::value` is an integral constant
expression that evaluates to /2/.]
[:`extent<int*>::value` is an integral constant
expression that evaluates to /0/.]
[:`extent<T>::value_type` is the type `std::size_t`.]
[endsect]

37
doc/floating_point_promotion.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:floating_point_promotion floating_point_promotion]
template <class T>
struct floating_point_promotion
{
typedef __below type;
};
__type If floating point promotion can be applied to an rvalue of type `T`,
then applies floating point promotion to `T` and keeps cv-qualifiers of `T`,
otherwise leaves `T` unchanged.
__std_ref 4.6.
__header ` #include <boost/type_traits/floating_point_promotion.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`floating_point_promotion<float const>::type`][`double const`]]
[[`floating_point_promotion<float&>::type`][`float&`]]
[[`floating_point_promotion<short>::type`][`short`]]
]
[endsect]

56
doc/function_traits.qbk Normal file
View File

@@ -0,0 +1,56 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:function_traits function_traits]
[def __argN '''arg<replaceable>N</replaceable>_type''']
template <class T>
struct function_traits
{
static const std::size_t arity = __below;
typedef __below result_type;
typedef __below __argN;
};
The class template function_traits will only compile if:
* The compiler supports partial specialization of class templates.
* The template argument `T` is a /function type/, note that this ['[*is not]]
the same thing as a /pointer to a function/.
[tip
function_traits is intended to introspect only C++ functions of the
form R (), R( A1 ), R ( A1, ... etc. ) and not function pointers or
class member functions. To convert a function pointer type to a suitable
type use __remove_pointer.]
[table Function Traits Members
[[Member] [Description]]
[[`function_traits<T>::arity`]
[An integral constant expression that gives the number of arguments accepted by the function type `F`.]]
[[`function_traits<T>::result_type`]
[The type returned by function type `F`.]]
[[`function_traits<T>::__argN`]
[The '''<replaceable>N</replaceable>th''' argument type of function type `F`, where `1 <= N <= arity` of `F`.]]
]
[table Examples
[[Expression] [Result]]
[[`function_traits<void (void)>::arity`] [An integral constant expression that has the value 0.]]
[[`function_traits<long (int)>::arity`] [An integral constant expression that has the value 1.]]
[[`function_traits<long (int, long, double, void*)>::arity`] [An integral constant expression that has the value 4.]]
[[`function_traits<void (void)>::result_type`] [The type `void`.]]
[[`function_traits<long (int)>::result_type`] [The type `long`.]]
[[`function_traits<long (int)>::arg1_type`] [The type `int`.]]
[[`function_traits<long (int, long, double, void*)>::arg4_type`] [The type `void*`.]]
[[`function_traits<long (int, long, double, void*)>::arg5_type`] [A compiler error: there is no `arg4_type` since there are only three arguments.]]
[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.]]
]
[endsect]

29
doc/has_nothrow_assign.qbk Normal file
View File

@@ -0,0 +1,29 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_nothrow_assign has_nothrow_assign]
template <class T>
struct has_nothrow_assign : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a non-throwing assignment-operator
then inherits from __true_type, otherwise inherits from __false_type. Type `T`
must be a complete type.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
`has_nothrow_assign` will never report that a class or struct has a
non-throwing assignment-operator; this is always safe, if possibly sub-optimal.
Currently (May 2005) only Visual C++ 8 has the necessary compiler support to ensure that this
trait "just works".
__header ` #include <boost/type_traits/has_nothrow_assign.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

34
doc/has_nothrow_constructor.qbk Normal file
View File

@@ -0,0 +1,34 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_nothrow_constructor has_nothrow_constructor]
template <class T>
struct has_nothrow_constructor : public __tof {};
template <class T>
struct has_nothrow_default_constructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a non-throwing default-constructor
then inherits from __true_type, otherwise inherits from __false_type. Type `T`
must be a complete type.
These two traits are synonyms for each other.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
`has_nothrow_constructor` will never report that a class or struct has a
non-throwing default-constructor; this is always safe, if possibly sub-optimal.
Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
trait "just works".
__header ` #include <boost/type_traits/has_nothrow_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

34
doc/has_nothrow_copy.qbk Normal file
View File

@@ -0,0 +1,34 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_nothrow_copy has_nothrow_copy]
template <class T>
struct has_nothrow_copy : public __tof {};
template <class T>
struct has_nothrow_copy_constructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a non-throwing copy-constructor
then inherits from __true_type, otherwise inherits from __false_type. Type `T`
must be a complete type.
These two traits are synonyms for each other.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
`has_nothrow_copy` will never report that a class or struct has a
non-throwing copy-constructor; this is always safe, if possibly sub-optimal.
Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
trait "just works".
__header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

47
doc/has_trivial_assign.qbk Normal file
View File

@@ -0,0 +1,47 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_trivial_assign has_trivial_assign]
template <class T>
struct has_trivial_assign : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a trivial assignment-operator
then inherits from __true_type, otherwise inherits from __false_type.
If a type has a trivial assignment-operator then the operator has the same effect
as copying the bits of one object to the other:
calls to the operator can be safely replaced with a call to `memcpy`.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
has_trivial_assign will never report that a user-defined class or struct has a
trivial constructor; this is always safe, if possibly sub-optimal. Currently
(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
user-defined classes with trivial constructors.
__std_ref 12.8p11.
__header ` #include <boost/type_traits/has_trivial_assign.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`has_trivial_assign<int>` inherits from `__true_type`.]
[:`has_trivial_assign<char*>::type` is the type `__true_type`.]
[:`has_trivial_assign<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`has_trivial_assign<MyClass>::value` is an integral constant
expression that evaluates to /false/.]
[:`has_trivial_assign<T>::value_type` is the type `bool`.]
[endsect]

55
doc/has_trivial_constructor.qbk Normal file
View File

@@ -0,0 +1,55 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_trivial_constructor has_trivial_constructor]
template <class T>
struct has_trivial_constructor : public __tof {};
template <class T>
struct has_trivial_default_constructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a trivial default-constructor
then inherits from __true_type, otherwise inherits from __false_type.
These two traits are synonyms for each other.
If a type has a trivial default-constructor then the constructor have no effect:
calls to the constructor can be safely omitted. Note that using meta-programming
to omit a call to a single trivial-constructor call is of no benefit whatsoever.
However, if loops and/or exception handling code can also be omitted, then some
benefit in terms of code size and speed can be obtained.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
has_trivial_constructor will never report that a user-defined class or struct has a
trivial constructor; this is always safe, if possibly sub-optimal. Currently
(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
user-defined classes with trivial constructors.
__std_ref 12.1p6.
__header ` #include <boost/type_traits/has_trivial_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`has_trivial_constructor<int>` inherits from `__true_type`.]
[:`has_trivial_constructor<char*>::type` is the type `__true_type`.]
[:`has_trivial_constructor<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`has_trivial_constructor<MyClass>::value` is an integral constant
expression that evaluates to /false/.]
[:`has_trivial_constructor<T>::value_type` is the type `bool`.]
[endsect]

53
doc/has_trivial_copy.qbk Normal file
View File

@@ -0,0 +1,53 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_trivial_copy has_trivial_copy]
template <class T>
struct has_trivial_copy : public __tof {};
template <class T>
struct has_trivial_copy_constructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a trivial copy-constructor
then inherits from __true_type, otherwise inherits from __false_type.
These two traits are synonyms for each other.
If a type has a trivial copy-constructor then the constructor has the same effect
as copying the bits of one object to the other:
calls to the constructor can be safely replaced with a call to `memcpy`.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
has_trivial_copy will never report that a user-defined class or struct has a
trivial constructor; this is always safe, if possibly sub-optimal. Currently
(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
user-defined classes with trivial constructors.
__std_ref 12.8p6.
__header ` #include <boost/type_traits/has_trivial_copy.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`has_trivial_copy<int>` inherits from `__true_type`.]
[:`has_trivial_copy<char*>::type` is the type `__true_type`.]
[:`has_trivial_copy<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`has_trivial_copy<MyClass>::value` is an integral constant
expression that evaluates to /false/.]
[:`has_trivial_copy<T>::value_type` is the type `bool`.]
[endsect]

49
doc/has_trivial_destructor.qbk Normal file
View File

@@ -0,0 +1,49 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_trivial_destructor has_trivial_destructor]
template <class T>
struct has_trivial_destructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a trivial destructor
then inherits from __true_type, otherwise inherits from __false_type.
If a type has a trivial destructor then the destructor has no effect:
calls to the destructor can be safely omitted. Note that using meta-programming
to omit a call to a single trivial-constructor call is of no benefit whatsoever.
However, if loops and/or exception handling code can also be omitted, then some
benefit in terms of code size and speed can be obtained.
__compat If the compiler does not support partial-specialization of class
templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler,
has_trivial_destructor will never report that a user-defined class or struct has a
trivial destructor; this is always safe, if possibly sub-optimal. Currently
(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
user-defined classes with trivial constructors.
__std_ref 12.4p3.
__header ` #include <boost/type_traits/has_trivial_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`has_trivial_destructor<int>` inherits from `__true_type`.]
[:`has_trivial_destructor<char*>::type` is the type `__true_type`.]
[:`has_trivial_destructor<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`has_trivial_destructor<MyClass>::value` is an integral constant
expression that evaluates to /false/.]
[:`has_trivial_destructor<T>::value_type` is the type `bool`.]
[endsect]

28
doc/has_virtual_destructor.qbk Normal file
View File

@@ -0,0 +1,28 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:has_virtual_destructor has_virtual_destructor]
template <class T>
struct has_virtual_destructor : public __tof {};
__inherit If T is a (possibly cv-qualified) type with a virtual destructor
then inherits from __true_type, otherwise inherits from __false_type.
__compat This trait is provided for completeness, since it's part of the
Technical Report on C++ Library Extensions. However, there is currently no
way to portably implement this trait. The default version provided
always inherits from __false_type, and has to be explicitly specialized for
types with virtual destructors unless the compiler used has compiler __intrinsics
that enable the trait to do the right thing: currently (May 2005) only Visual C++
8 has the necessary __intrinsics.
__std_ref 12.4.
__header ` #include <boost/type_traits/has_virtual_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

26
doc/integral_constant.qbk Normal file
View File

@@ -0,0 +1,26 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:integral_constant integral_constant]
template <class T, T val>
struct integral_constant
{
typedef integral_constant<T, val> type;
typedef T value_type;
static const T value = val;
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
Class template `integral_constant` is the common base class for all the value-based
type traits. The two typedef's `true_type` and `false_type` are provided for
convenience: most of the value traits are Boolean properties and so will inherit from
one of these.
[endsect]

37
doc/integral_promotion.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:integral_promotion integral_promotion]
template <class T>
struct integral_promotion
{
typedef __below type;
};
__type If integral promotion can be applied to an rvalue of type `T`, then
applies integral promotion to `T` and keeps cv-qualifiers of `T`,
otherwise leaves `T` unchanged.
__std_ref 4.5 except 4.5/3 (integral bit-field).
__header ` #include <boost/type_traits/integral_promotion.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`integral_promotion<short const>::type`][`int const`]]
[[`integral_promotion<short&>::type`][`short&`]]
[[`integral_promotion<enum std::float_round_style>::type`][`int`]]
]
[endsect]

62
doc/intrinsics.qbk Normal file
View File

@@ -0,0 +1,62 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:intrinsics Support for Compiler Intrinsics]
There are some traits that can not be implemented within the current C++ language:
to make these traits "just work" with user defined types, some kind of additional
help from the compiler is required. Currently (May 2005) MWCW 9 and Visual C++ 8
provide the necessary intrinsics, and other compilers will no doubt follow in due
course.
The Following traits classes always need compiler support to do the right thing
for all types
(but all have safe fallback positions if this support is unavailable):
* __is_union
* __is_pod
* __has_trivial_constructor
* __has_trivial_copy
* __has_trivial_assign
* __has_trivial_destructor
* __has_nothrow_constructor
* __has_nothrow_copy
* __has_nothrow_assign
* __has_virtual_destructor
The following traits classes can't be portably implemented in the C++ language,
although in practice, the implementations do in fact do the right thing on all
the compilers we know about:
* __is_empty
* __is_polymorphic
The following traits classes are dependent on one or more of the above:
* __is_class
* __is_stateless
The hooks for compiler-intrinsic support are defined in
[@../../boost/type_traits/intrinsics.hpp boost/type_traits/intrinsics.hpp], adding support for new compilers is simply
a matter of defining one of more of the following macros:
[table Macros for Compiler Intrinsics
[[BOOST_IS_UNION(T)][Should evaluate to true if T is a union type]]
[[BOOST_IS_POD(T)][Should evaluate to true if T is a POD type]]
[[BOOST_IS_EMPTY(T)][Should evaluate to true if T is an empty struct or union]]
[[BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)][Should evaluate to true if the default constructor for T is trivial (i.e. has no effect)]]
[[BOOST_HAS_TRIVIAL_COPY(T)][Should evaluate to true if T has a trivial copy constructor (and can therefore be replaced by a call to memcpy)]]
[[BOOST_HAS_TRIVIAL_ASSIGN(T)][Should evaluate to true if T has a trivial assignment operator (and can therefore be replaced by a call to memcpy)]]
[[BOOST_HAS_TRIVIAL_DESTRUCTOR(T)][Should evaluate to true if T has a trivial destructor (i.e. ~T() has no effect)]]
[[BOOST_HAS_NOTHROW_CONSTRUCTOR(T)][Should evaluate to true if `T x;` can not throw]]
[[BOOST_HAS_NOTHROW_COPY(T)][Should evaluate to true if `T(t)` can not throw]]
[[BOOST_HAS_NOTHROW_ASSIGN(T)][Should evaluate to true if `T t, u; t = u` can not throw]]
[[BOOST_HAS_VIRTUAL_DESTRUCTOR(T)][Should evaluate to true T has a virtual destructor]]
]
[endsect]

41
doc/is_abstract.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_abstract is_abstract]
template <class T>
struct is_abstract : public __tof {};
__inherit If T is a (possibly cv-qualified) abstract type then inherits from
__true_type, otherwise inherits from __false_type.
__std_ref 10.3.
__header ` #include <boost/type_traits/is_abstract.hpp>` or ` #include <boost/type_traits.hpp>`
__compat The compiler must support DR337 (as of April 2005: GCC 3.4, VC++ 7.1 (and later),
Intel C++ 7 (and later), and Comeau 4.3.2).
Otherwise behaves the same as __is_polymorphic;
this is the "safe fallback position" for which polymorphic types are always
regarded as potentially abstract. The macro BOOST_NO_IS_ABSTRACT is used to
signify that the implementation is buggy, users should check for this in their
own code if the "safe fallback" is not suitable for their particular use-case.
__examples
[:Given: `class abc{ virtual ~abc() = 0; };` ]
[:`is_abstract<abc>` inherits from `__true_type`.]
[:`is_abstract<abc>::type` is the type `__true_type`.]
[:`is_abstract<abc const>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_abstract<T>::value_type` is the type `bool`.]
[endsect]

32
doc/is_arithmetic.qbk Normal file
View File

@@ -0,0 +1,32 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_arithmetic is_arithmetic]
template <class T>
struct is_arithmetic : public __tof {};
__inherit If T is a (possibly cv-qualified) arithmetic type then inherits from
__true_type, otherwise inherits from __false_type. Arithmetic types include
integral and floating point types (see also __is_integral and __is_floating_point).
__std_ref 3.9.1p8.
__header ` #include <boost/type_traits/is_arithmetic.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_arithmetic<int>` inherits from `__true_type`.]
[:`is_arithmetic<char>::type` is the type `__true_type`.]
[:`is_arithmetic<double>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_arithmetic<T>::value_type` is the type `bool`.]
[endsect]

35
doc/is_array.qbk Normal file
View File

@@ -0,0 +1,35 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_array is_array]
template <class T>
struct is_array : public __tof {};
__inherit If T is a (possibly cv-qualified) array type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 8.3.4.
__header ` #include <boost/type_traits/is_array.hpp>` or ` #include <boost/type_traits.hpp>`
__compat If the compiler does not support
partial-specialization of class templates, then this template
can give the wrong result with function types.
__examples
[:`is_array<int[2]>` inherits from `__true_type`.]
[:`is_array<char[2][3]>::type` is the type `__true_type`.]
[:`is_array<double[]>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_array<T>::value_type` is the type `bool`.]
[endsect]

54
doc/is_base_of.qbk Normal file
View File

@@ -0,0 +1,54 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_base_of is_base_of]
template <class Base, class Derived>
struct is_base_of : public __tof {};
__inherit If Base is base class of type Derived or if both types are the same
then inherits from __true_type,
otherwise inherits from __false_type.
This template will detect non-public base classes, and ambiguous base classes.
Note that `is_base_of<X,X>` will always inherit from __true_type. [*This is the
case even if `X` is not a class type]. This is a change in behaviour
from Boost-1.33 in order to track the Technical Report on C++ Library Extensions.
Types `Base` and `Derived` must not be incomplete types.
__std_ref 10.
__header ` #include <boost/type_traits/is_base_of.hpp>` or ` #include <boost/type_traits.hpp>`
__compat If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types. There are some older compilers
which will produce compiler errors if `Base` is a private base class of `Derived`, or if
`Base` is an ambiguous base of `Derived`. These compilers include Borland C++, older
versions of Sun Forte C++, Digital Mars C++, and older versions of EDG based compilers.
__examples
[:Given: ` class Base{}; class Derived : public Base{};` ]
[:`is_base_of<Base, Derived>` inherits from `__true_type`.]
[:`is_base_of<Base, Derived>::type` is the type `__true_type`.]
[:`is_base_of<Base, Derived>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_base_of<Base, Derived>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_base_of<Base, Base>::value` is an integral constant
expression that evaluates to /true/: a class is regarded as it's own base.]
[:`is_base_of<T>::value_type` is the type `bool`.]
[endsect]

45
doc/is_class.qbk Normal file
View File

@@ -0,0 +1,45 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_class is_class]
template <class T>
struct is_class : public __tof {};
__inherit If T is a (possibly cv-qualified) class type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 9.2.
__header ` #include <boost/type_traits/is_class.hpp>` or ` #include <boost/type_traits.hpp>`
__compat Without (some as yet unspecified) help from the compiler,
we cannot distinguish between union and class types, as a result this type
will erroneously inherit from __true_type for union types. See also __is_union.
Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to
correctly identify union types, and therefore make is_class function correctly.
__examples
[:Given: `class MyClass;` then:]
[:`is_class<MyClass>` inherits from `__true_type`.]
[:`is_class<MyClass const>::type` is the type `__true_type`.]
[:`is_class<MyClass>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_class<MyClass&>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_class<MyClass*>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_class<T>::value_type` is the type `bool`.]
[endsect]

21
doc/is_complex.qbk Normal file
View File

@@ -0,0 +1,21 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_complex is_complex]
template <class T>
struct is_complex : public __tof {};
__inherit If `T` is a complex number type then true (of type `std::complex<U>` for
some type `U`), otherwise false.
__std_ref 26.2.
__header ` #include <boost/type_traits/is_complex.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

38
doc/is_compound.qbk Normal file
View File

@@ -0,0 +1,38 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_compound is_compound]
template <class T>
struct is_compound : public __tof {};
__inherit If T is a (possibly cv-qualified) compound type then inherits from __true_type,
otherwise inherits from __false_type. Any type that is not a fundamental type is
a compound type (see also __is_fundamental).
__std_ref 3.9.2.
__header ` #include <boost/type_traits/is_compound.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_compound<MyClass>` inherits from `__true_type`.]
[:`is_compound<MyEnum>::type` is the type `__true_type`.]
[:`is_compound<int*>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_compound<int&>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_compound<int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_compound<T>::value_type` is the type `bool`.]
[endsect]

43
doc/is_const.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_const is_const]
template <class T>
struct is_const : public __tof {};
__inherit If T is a (top level) const-qualified type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.3.
__header ` #include <boost/type_traits/is_const.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_const<int const>` inherits from `__true_type`.]
[:`is_const<int const volatile>::type` is the type `__true_type`.]
[:`is_const<int* const>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_const<int const*>::value` is an integral constant
expression that evaluates to /false/: the const-qualifier is not
at the top level in this case.]
[:`is_const<int const&>::value` is an integral constant
expression that evaluates to /false/: the const-qualifier is not
at the top level in this case.]
[:`is_const<int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_const<T>::value_type` is the type `bool`.]
[endsect]

66
doc/is_convertible.qbk Normal file
View File

@@ -0,0 +1,66 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_convertible is_convertible]
template <class From, class To>
struct is_convertible : public __tof {};
__inherit If an imaginary lvalue of type `From` is convertible to type `To` then
inherits from __true_type, otherwise inherits from __false_type.
Type From must not be an incomplete type.
Type To must not be an incomplete, or function type.
No types are considered to be convertible to array types or abstract-class types.
This template can not detect whether a converting-constructor is `public` or not: if
type `To` has a `private` converting constructor from type `From` then instantiating
`is_convertible<From, To>` will produce a compiler error. For this reason `is_convertible`
can not be used to determine whether a type has a `public` copy-constructor or not.
This template will also produce compiler errors if the conversion is ambiguous,
for example:
struct A {};
struct B : A {};
struct C : A {};
struct D : B, C {};
// This produces a compiler error, the conversion is ambiguous:
bool const y = boost::is_convertible<D*,A*>::value;
__std_ref 4 and 8.5.
__compat This template is currently broken with Borland C++ Builder 5 (and earlier),
for constructor-based conversions, and for the Metrowerks 7 (and earlier)
compiler in all cases. If the compiler does not support `__is_abstract`, then the
template parameter `To` must not be an abstract type.
__header ` #include <boost/type_traits/is_convertible.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_convertible<int, double>` inherits from `__true_type`.]
[:`is_convertible<const int, double>::type` is the type `__true_type`.]
[:`is_convertible<int* const, int*>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_convertible<int const*, int*>::value` is an integral constant
expression that evaluates to /false/: the conversion would require a `const_cast`.]
[:`is_convertible<int const&, long>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_convertible<int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_convertible<T>::value_type` is the type `bool`.]
[endsect]

45
doc/is_empty.qbk Normal file
View File

@@ -0,0 +1,45 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_empty is_empty]
template <class T>
struct is_empty : public __tof {};
__inherit If T is an empty class type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 10p5.
__header ` #include <boost/type_traits/is_empty.hpp>` or ` #include <boost/type_traits.hpp>`
__compat In order to correctly detect empty classes this trait relies on either:
* the compiler implementing zero sized empty base classes, or
* the compiler providing __intrinsics to detect empty classes.
Can not be used with incomplete types.
Can not be used with union types, until is_union can be made to work.
If the compiler does not support partial-specialization of class templates,
then this template can not be used with abstract types.
__examples
[:Given: `struct empty_class {};` ]
[:`is_empty<empty_class>` inherits from `__true_type`.]
[:`is_empty<empty_class const>::type` is the type `__true_type`.]
[:`is_empty<empty_class>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_empty<T>::value_type` is the type `bool`.]
[endsect]

44
doc/is_enum.qbk Normal file
View File

@@ -0,0 +1,44 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_enum is_enum]
template <class T>
struct is_enum : public __tof {};
__inherit If T is a (possibly cv-qualified) enum type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 7.2.
__header ` #include <boost/type_traits/is_enum.hpp>` or ` #include <boost/type_traits.hpp>`
__compat Requires a correctly functioning __is_convertible template;
this means that is_enum is currently broken under Borland C++ Builder 5,
and for the Metrowerks compiler prior to version 8, other compilers
should handle this template just fine.
__examples
[:Given: `enum my_enum { one, two };` ]
[:`is_enum<my_enum>` inherits from `__true_type`.]
[:`is_enum<my_enum const>::type` is the type `__true_type`.]
[:`is_enum<my_enum>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_enum<my_enum&>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_enum<my_enum*>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_enum<T>::value_type` is the type `bool`.]
[endsect]

31
doc/is_floating_point.qbk Normal file
View File

@@ -0,0 +1,31 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_floating_point is_floating_point]
template <class T>
struct is_floating_point : public __tof {};
__inherit If T is a (possibly cv-qualified) floating point type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.1p8.
__header ` #include <boost/type_traits/is_floating_point.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_floating_point<float>` inherits from `__true_type`.]
[:`is_floating_point<double>::type` is the type `__true_type`.]
[:`is_floating_point<long double>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_floating_point<T>::value_type` is the type `bool`.]
[endsect]

74
doc/is_function.qbk Normal file
View File

@@ -0,0 +1,74 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_function is_function]
template <class T>
struct is_function : public __tof {};
__inherit If T is a (possibly cv-qualified) function type then inherits from __true_type,
otherwise inherits from __false_type. Note that this template does not detect /pointers
to functions/, or /references to functions/, these are detected by __is_pointer and
__is_reference respectively:
typedef int f1(); // f1 is of function type.
typedef int (f2*)(); // f2 is a pointer to a function.
typedef int (f3&)(); // f3 is a reference to a function.
__std_ref 3.9.2p1 and 8.3.5.
__header ` #include <boost/type_traits/is_function.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_function<int (void)>` inherits from `__true_type`.]
[:`is_function<long (double, int)>::type` is the type `__true_type`.]
[:`is_function<long (double, int)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_function<long (*)(double, int)>::value` is an integral constant
expression that evaluates to /false/: the argument in this case is a pointer type,
not a function type.]
[:`is_function<long (&)(double, int)>::value` is an integral constant
expression that evaluates to /false/: the argument in this case is a
reference to a function, not a function type.]
[:`is_function<long (MyClass::*)(double, int)>::value` is an integral constant
expression that evaluates to /false/: the argument in this case is a pointer
to a member function.]
[:`is_function<T>::value_type` is the type `bool`.]
[tip Don't confuse function-types with pointers to functions:
`typedef int f(double);`
defines a function type,
`f foo;`
declares a prototype for a function of type `f`,
`f* pf = foo;`
`f& fr = foo;`
declares a pointer and a reference to the function `foo`.
If you want to detect whether some type is a pointer-to-function then use:
`__is_function<__remove_pointer<T>::type>::value && __is_pointer<T>::value`
or for pointers to member functions you can just use
__is_member_function_pointer directly.
]
[endsect]

32
doc/is_fundamental.qbk Normal file
View File

@@ -0,0 +1,32 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_fundamental is_fundamental]
template <class T>
struct is_fundamental : public __tof {};
__inherit If T is a (possibly cv-qualified) fundamental type then inherits from __true_type,
otherwise inherits from __false_type. Fundamental types include integral, floating
point and void types (see also __is_integral, __is_floating_point and __is_void)
__std_ref 3.9.1.
__header ` #include <boost/type_traits/is_fundamental.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_fundamental<int)>` inherits from `__true_type`.]
[:`is_fundamental<double const>::type` is the type `__true_type`.]
[:`is_fundamental<void>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_fundamental<T>::value_type` is the type `bool`.]
[endsect]

31
doc/is_integral.qbk Normal file
View File

@@ -0,0 +1,31 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_integral is_integral]
template <class T>
struct is_integral : public __tof {};
__inherit If T is a (possibly cv-qualified) integral type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.1p7.
__header ` #include <boost/type_traits/is_integral.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_integral<int>` inherits from `__true_type`.]
[:`is_integral<const char>::type` is the type `__true_type`.]
[:`is_integral<long>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_integral<T>::value_type` is the type `bool`.]
[endsect]

37
doc/is_member_function_pointer.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_member_function_pointer is_member_function_pointer]
template <class T>
struct is_member_function_pointer : public __tof {};
__inherit If T is a (possibly cv-qualified) pointer to a member function
then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 8.3.3.
__header ` #include <boost/type_traits/is_member_function_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_member_function_pointer<int (MyClass::*)(void)>` inherits from `__true_type`.]
[:`is_member_function_pointer<int (MyClass::*)(char)>::type` is the type `__true_type`.]
[:`is_member_function_pointer<int (MyClass::*)(void)const>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_member_function_pointer<int (MyClass::*)>::value` is an integral constant
expression that evaluates to /false/: the argument in this case is a pointer to
a data member and not a member function, see __is_member_object_pointer
and __is_member_pointer]
[:`is_member_function_pointer<T>::value_type` is the type `bool`.]
[endsect]

37
doc/is_member_object_pointer.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_member_object_pointer is_member_object_pointer]
template <class T>
struct is_member_object_pointer : public __tof {};
__inherit If T is a (possibly cv-qualified) pointer to a member object (a data member)
then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 8.3.3.
__header ` #include <boost/type_traits/is_member_object_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_member_object_pointer<int (MyClass::*)>` inherits from `__true_type`.]
[:`is_member_object_pointer<double (MyClass::*)>::type` is the type `__true_type`.]
[:`is_member_object_pointer<const int (MyClass::*)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_member_object_pointer<int (MyClass::*)(void)>::value` is an integral constant
expression that evaluates to /false/: the argument in this case is a pointer to
a member function and not a member object, see __is_member_function_pointer
and __is_member_pointer]
[:`is_member_object_pointer<T>::value_type` is the type `bool`.]
[endsect]

33
doc/is_member_pointer.qbk Normal file
View File

@@ -0,0 +1,33 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_member_pointer is_member_pointer]
template <class T>
struct is_member_pointer : public __tof {};
__inherit If T is a (possibly cv-qualified) pointer to a member (either a function
or a data member)
then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 8.3.3.
__header ` #include <boost/type_traits/is_member_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_member_pointer<int (MyClass::*)>` inherits from `__true_type`.]
[:`is_member_pointer<int (MyClass::*)(char)>::type` is the type `__true_type`.]
[:`is_member_pointer<int (MyClass::*)(void)const>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_member_pointer<T>::value_type` is the type `bool`.]
[endsect]

45
doc/is_object.qbk Normal file
View File

@@ -0,0 +1,45 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_object is_object]
template <class T>
struct is_object : public __tof {};
__inherit If T is a (possibly cv-qualified) object type
then inherits from __true_type,
otherwise inherits from __false_type. All types are object types except
references, void, and function types.
__std_ref 3.9p9.
__header ` #include <boost/type_traits/is_object.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_object<int>` inherits from `__true_type`.]
[:`is_object<int*>::type` is the type `__true_type`.]
[:`is_object<int (*)(void)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_object<int (MyClass::*)(void)const>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_object<int &>::value` is an integral constant
expression that evaluates to /false/: reference types are not objects]
[:`is_object<int (double)>::value` is an integral constant
expression that evaluates to /false/: function types are not objects]
[:`is_object<const void>::value` is an integral constant
expression that evaluates to /false/: void is not an object type]
[:`is_object<T>::value_type` is the type `bool`.]
[endsect]

51
doc/is_pod.qbk Normal file
View File

@@ -0,0 +1,51 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_pod is_pod]
template <class T>
struct is_pod : public __tof {};
__inherit If T is a (possibly cv-qualified) POD type then inherits from __true_type,
otherwise inherits from __false_type.
POD stands for "Plain old data".
Arithmetic types, and enumeration types,
a pointers and pointer to members are all PODs. Classes and unions can also
be POD's if they have no non-static data members that are of reference or
non-POD type, no user defined constructors, no user defined assignment
operators, no private or protected non-static data members,
no virtual functions and no base classes. Finally, a cv-qualified POD is
still a POD, as is an array of PODs.
__std_ref 3.9p10 and 9p4 (Note that POD's are also aggregates, see 8.5.1).
__compat If the compiler does not support partial-specialization
of class templates, then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler, is_pod will
never report that a class or struct is a POD; this is always safe,
if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the
necessary compiler-__intrinsics.
__header ` #include <boost/type_traits/is_pod.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_pod<int>` inherits from `__true_type`.]
[:`is_pod<char*>::type` is the type `__true_type`.]
[:`is_pod<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_pod<MyClass>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_pod<T>::value_type` is the type `bool`.]
[endsect]

45
doc/is_pointer.qbk Normal file
View File

@@ -0,0 +1,45 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_pointer is_pointer]
template <class T>
struct is_pointer : public __tof {};
__inherit If T is a (possibly cv-qualified) pointer type (includes function pointers,
but excludes pointers to members) then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2p2 and 8.3.1.
__header ` #include <boost/type_traits/is_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_pointer<int*>` inherits from `__true_type`.]
[:`is_pointer<char* const>::type` is the type `__true_type`.]
[:`is_pointer<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_pointer<int (MyClass::*)(long)>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_pointer<int (MyClass::*)>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_pointer<T>::value_type` is the type `bool`.]
[important `is_pointer` detects "real" pointer types only, and /not/ smart pointers.
Users should not specialise `is_pointer` for smart pointer types, as doing so may cause
Boost (and other third party) code to fail to function correctly.
Users wanting a trait to detect smart pointers should create their own.
However, note that there is no way in general to auto-magically detect smart pointer types,
so such a trait would have to be partially specialised for each supported smart pointer type.]
[endsect]

37
doc/is_polymorphic.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_polymorphic is_polymorphic]
template <class T>
struct is_polymorphic : public __tof {};
__inherit If T is a (possibly cv-qualified) polymorphic type
then inherits from __true_type,
otherwise inherits from __false_type. Type `T` must be a complete type.
__std_ref 10.3.
__compat The implementation requires some knowledge of the compilers ABI,
it does actually seem to work with the majority of compilers though.
__header ` #include <boost/type_traits/is_polymorphic.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[: Given: `class poly{ virtual ~poly(); };` ]
[:`is_polymorphic<poly>` inherits from `__true_type`.]
[:`is_polymorphic<poly const>::type` is the type `__true_type`.]
[:`is_polymorphic<poly>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_polymorphic<T>::value_type` is the type `bool`.]
[endsect]

37
doc/is_reference.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_reference is_reference]
template <class T>
struct is_reference : public __tof {};
__inherit If T is a reference pointer type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.2 and 8.3.2.
__compat If the compiler does not
support partial-specialization of class templates,
then this template may report the wrong result for function types,
and for types that are both const and volatile qualified.
__header ` #include <boost/type_traits/is_reference.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_reference<int&>` inherits from `__true_type`.]
[:`is_reference<int const&>::type` is the type `__true_type`.]
[:`is_reference<int (&)(long)>::value` is an integral constant
expression that evaluates to /true/ (the argument in this case is
a reference to a function).]
[:`is_reference<T>::value_type` is the type `bool`.]
[endsect]

38
doc/is_same.qbk Normal file
View File

@@ -0,0 +1,38 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_same is_same]
template <class T, class U>
struct is_same : public __tof {};
__inherit If T and U are the same types then inherits from
__true_type, otherwise inherits from __false_type.
__header ` #include <boost/type_traits/is_same.hpp>` or ` #include <boost/type_traits.hpp>`
__compat If the compiler does not support partial-specialization of class templates,
then this template can not be used with abstract, incomplete or function types.
__examples
[:`is_same<int, int>` inherits from `__true_type`.]
[:`is_same<int, int>::type` is the type `__true_type`.]
[:`is_same<int, int>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_same<int const, int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_same<int&, int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_same<T>::value_type` is the type `bool`.]
[endsect]

44
doc/is_scalar.qbk Normal file
View File

@@ -0,0 +1,44 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_scalar is_scalar]
template <class T>
struct is_scalar : public __tof {};
__inherit If T is a (possibly cv-qualified) scalar type then inherits from
__true_type, otherwise inherits from __false_type. Scalar types include
integral, floating point, enumeration, pointer, and pointer-to-member types.
__std_ref 3.9p10.
__header ` #include <boost/type_traits/is_scalar.hpp>` or ` #include <boost/type_traits.hpp>`
__compat If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.
__examples
[:`is_scalar<int*>` inherits from `__true_type`.]
[:`is_scalar<int>::type` is the type `__true_type`.]
[:`is_scalar<double>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_scalar<int (*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_scalar<int (MyClass::*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_scalar<int (MyClass::*)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_scalar<T>::value_type` is the type `bool`.]
[endsect]

42
doc/is_signed.qbk Normal file
View File

@@ -0,0 +1,42 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_signed is_signed]
template <class T>
struct is_signed : public __tof {};
__inherit If T is an signed integer type or an enumerated type with an
underlying signed integer type, then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.1, 7.2.
__header ` #include <boost/type_traits/is_signed.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_signed<int>` inherits from `__true_type`.]
[:`is_signed<int const volatile>::type` is the type `__true_type`.]
[:`is_signed<unsigned int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_signed<myclass>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_signed<char>::value` is an integral constant
expression whose value depends upon the signedness of type `char`.]
[:`is_signed<long long>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_signed<T>::value_type` is the type `bool`.]
[endsect]

40
doc/is_stateless.qbk Normal file
View File

@@ -0,0 +1,40 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_stateless is_stateless]
template <class T>
struct is_stateless : public __tof {};
__inherit Ff T is a stateless type then inherits from __true_type, otherwise
from __false_type.
Type T must be a complete type.
A stateless type is a type that has no storage and whose constructors and
destructors are trivial. That means that `is_stateless` only inherits from
__true_type if the following expression is `true`:
::boost::has_trivial_constructor<T>::value
&& ::boost::has_trivial_copy<T>::value
&& ::boost::has_trivial_destructor<T>::value
&& ::boost::is_class<T>::value
&& ::boost::is_empty<T>::value
__std_ref 3.9p10.
__header ` #include <boost/type_traits/is_stateless.hpp>` or ` #include <boost/type_traits.hpp>`
__compat If the compiler does not support partial-specialization of class templates,
then this template can not be used with function types.
Without some (as yet unspecified) help from the compiler, is_stateless will never
report that a class or struct is stateless; this is always safe,
if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary
compiler __intrinsics to make this template work automatically.
[endsect]

43
doc/is_union.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_union is_union]
template <class T>
struct is_union : public __tof {};
__inherit If T is a (possibly cv-qualified) union type then inherits from __true_type,
otherwise inherits from __false_type. Currently requires some kind of compiler
support, otherwise unions are identified as classes.
__std_ref 3.9.2 and 9.5.
__compat Without (some as yet unspecified) help from the
compiler, we cannot distinguish between union and class types using only standard C++,
as a result this type will never inherit from __true_type, unless the user explicitly
specializes the template for their user-defined union types, or unless the compiler
supplies some unspecified intrinsic that implements this functionality. Currently
(May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to make this
trait "just work" without user intervention.
__header ` #include <boost/type_traits/is_union.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_union<void>` inherits from `__true_type`.]
[:`is_union<const void>::type` is the type `__true_type`.]
[:`is_union<void>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_union<void*>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_union<T>::value_type` is the type `bool`.]
[endsect]

42
doc/is_unsigned.qbk Normal file
View File

@@ -0,0 +1,42 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_unsigned is_unsigned]
template <class T>
struct is_unsigned : public __tof {};
__inherit If T is an unsigned integer type or an enumerated type with an
underlying unsigned integer type, then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.1, 7.2.
__header ` #include <boost/type_traits/is_unsigned.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_unsigned<unsigned int>` inherits from `__true_type`.]
[:`is_unsigned<unsigned int const volatile>::type` is the type `__true_type`.]
[:`is_unsigned<int>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_unsigned<myclass>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_unsigned<char>::value` is an integral constant
expression whose value depends upon the signedness of type `char`.]
[:`is_unsigned<unsigned long long>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_unsigned<T>::value_type` is the type `bool`.]
[endsect]

34
doc/is_void.qbk Normal file
View File

@@ -0,0 +1,34 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_void is_void]
template <class T>
struct is_void : public __tof {};
__inherit If T is a (possibly cv-qualified) void type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.1p9.
__header ` #include <boost/type_traits/is_void.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_void<void>` inherits from `__true_type`.]
[:`is_void<const void>::type` is the type `__true_type`.]
[:`is_void<void>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_void<void*>::value` is an integral constant
expression that evaluates to /false/.]
[:`is_void<T>::value_type` is the type `bool`.]
[endsect]

35
doc/is_volatile.qbk Normal file
View File

@@ -0,0 +1,35 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:is_volatile is_volatile]
template <class T>
struct is_volatile : public __tof {};
__inherit If T is a (top level) volatile-qualified type then inherits from __true_type,
otherwise inherits from __false_type.
__std_ref 3.9.3.
__header ` #include <boost/type_traits/is_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`is_volatile<volatile int>` inherits from `__true_type`.]
[:`is_volatile<const volatile int>::type` is the type `__true_type`.]
[:`is_volatile<int* volatile>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_volatile<int volatile*>::value` is an integral constant
expression that evaluates to /false/: the volatile qualifier is not
at the top level in this case.]
[:`is_volatile<T>::value_type` is the type `bool`.]
[endsect]

47
doc/make_signed.qbk Normal file
View File

@@ -0,0 +1,47 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:make_signed make_signed]
template <class T>
struct make_signed
{
typedef __below type;
};
__type If T is a signed integer type then the same type as T, if T is an
unsigned integer type then the corresponding signed type.
Otherwise if T is an enumerated or
character type (char or wchar_t) then a signed integer type with the same
width as T.
If T has any cv-qualifiers then these are also present on the result type.
[*Requires:] T must be an integer or enumerated type, and must not be the type
bool.
__std_ref 3.9.1.
__header ` #include <boost/type_traits/make_signed.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`make_signed<int>::type`][`int`]]
[[`make_signed<unsigned int const>::type`] [`int const`]]
[[`make_signed<const unsigned long long>::type`] [`const long long`]]
[[`make_signed<my_enum>::type`] [A signed integer type with the same width as the enum.]]
[[`make_signed<wchar_t>::type`] [A signed integer type with the same width as wchar_t.]]
]
[endsect]

47
doc/make_unsigned.qbk Normal file
View File

@@ -0,0 +1,47 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:make_unsigned make_unsigned]
template <class T>
struct make_unsigned
{
typedef __below type;
};
__type If T is a unsigned integer type then the same type as T, if T is an
signed integer type then the corresponding unsigned type.
Otherwise if T is an enumerated or
character type (char or wchar_t) then an unsigned integer type with the same
width as T.
If T has any cv-qualifiers then these are also present on the result type.
[*Requires:] T must be an integer or enumerated type, and must not be the type
bool.
__std_ref 3.9.1.
__header ` #include <boost/type_traits/make_unsigned.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`make_signed<int>::type`][`unsigned int`]]
[[`make_signed<unsigned int const>::type`] [`unsigned int const`]]
[[`make_signed<const unsigned long long>::type`] [`const unsigned long long`]]
[[`make_signed<my_enum>::type`] [An unsigned integer type with the same width as the enum.]]
[[`make_signed<wchar_t>::type`] [An unsigned integer type with the same width as wchar_t.]]
]
[endsect]

20
doc/mpl.qbk Normal file
View File

@@ -0,0 +1,20 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:mpl MPL Interoperability]
All the value based traits in this library conform to MPL's requirements
for an [@../../libs/mpl/doc/refmanual/integral-constant.html Integral Constant type]: that includes a number of rather intrusive
workarounds for broken compilers.
Purely as an implementation detail, this
means that `__true_type` inherits from [@../../libs/mpl/doc/refmanual/bool.html `boost::mpl::true_`], `__false_type` inherits
from [@../../libs/mpl/doc/refmanual/bool.html `boost::mpl::false_`], and `__integral_constant<T, v>` inherits from
[@../../libs/mpl/doc/refmanual/integral-c.html `boost::mpl::integral_c<T,v>`] (provided `T` is not `bool`)
[endsect]

38
doc/promote.qbk Normal file
View File

@@ -0,0 +1,38 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:promote promote]
template <class T>
struct promote
{
typedef __below type;
};
__type If integral or floating point promotion can be applied to an rvalue
of type `T`, then applies integral and floating point promotions to `T` and
keeps cv-qualifiers of `T`, otherwise leaves `T` unchanged. See also
__integral_promotion and __floating_point_promotion.
__std_ref 4.5 except 4.5/3 (integral bit-field) and 4.6.
__header ` #include <boost/type_traits/promote.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`promote<short volatile>::type`][`int volatile`]]
[[`promote<float const>::type`][`double const`]]
[[`promote<short&>::type`][`short&`]]
]
[endsect]

37
doc/rank.qbk Normal file
View File

@@ -0,0 +1,37 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:rank rank]
template <class T>
struct rank : public __integral_constant<std::size_t, RANK(T)> {};
__inherit Class template rank inherits from `__integral_constant<std::size_t, RANK(T)>`,
where `RANK(T)` is the number of array dimensions in type `T`.
If `T` is not an array type, then `RANK(T)` is zero.
__header ` #include <boost/type_traits/rank.hpp>` or ` #include <boost/type_traits.hpp>`
__examples
[:`rank<int[]>` inherits from `__integral_constant<std::size_t, 1>`.]
[:`rank<double[2][3][4]>::type` is the type `__integral_constant<std::size_t, 3>`.]
[:`rank<int[1]>::value` is an integral constant
expression that evaluates to /1/.]
[:`rank<int[][2]>::value` is an integral constant
expression that evaluates to /2/.]
[:`rank<int*>::value` is an integral constant
expression that evaluates to /0/.]
[:`rank<T>::value_type` is the type `std::size_t`.]
[endsect]

44
doc/remove_all_extents.qbk Normal file
View File

@@ -0,0 +1,44 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_all_extents remove_all_extents]
template <class T>
struct remove_all_extents
{
typedef __below type;
};
__type If `T` is an array type, then removes all of the array bounds on `T`, otherwise
leaves `T` unchanged.
__std_ref 8.3.4.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_all_extents.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_all_extents<int>::type`][`int`]]
[[`remove_all_extents<int const[2]>::type`] [`int const`]]
[[`remove_all_extents<int[][2]>::type`] [`int`]]
[[`remove_all_extents<int[2][3][4]>::type`] [`int`]]
[[`remove_all_extents<int const*>::type`] [`int const*`]]
]
[endsect]

43
doc/remove_const.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_const remove_const]
template <class T>
struct remove_const
{
typedef __below type;
};
__type The same type as `T`, but with any /top level/ const-qualifier removed.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_const.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_const<int>::type`][`int`]]
[[`remove_const<int const>::type`] [`int`]]
[[`remove_const<int const volatile>::type`] [`int volatile`]]
[[`remove_const<int const&>::type`] [`int const&`]]
[[`remove_const<int const*>::type`] [`int const*`]]
]
[endsect]

43
doc/remove_cv.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_cv remove_cv]
template <class T>
struct remove_cv
{
typedef __below type;
};
__type The same type as `T`, but with any /top level/ cv-qualifiers removed.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_cv.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_cv<int>::type`][`int`]]
[[`remove_cv<int const>::type`] [`int`]]
[[`remove_cv<int const volatile>::type`] [`int`]]
[[`remove_cv<int const&>::type`] [`int const&`]]
[[`remove_cv<int const*>::type`] [`int const*`]]
]
[endsect]

44
doc/remove_extent.qbk Normal file
View File

@@ -0,0 +1,44 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_extent remove_extent]
template <class T>
struct remove_extent
{
typedef __below type;
};
__type If `T` is an array type, then removes the topmost array bound,
otherwise leaves `T` unchanged.
__std_ref 8.3.4.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_extent.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_extent<int>::type`][`int`]]
[[`remove_extent<int const[2]>::type`] [`int const`]]
[[`remove_extent<int[2][4]>::type`] [`int[4]`]]
[[`remove_extent<int[][2]>::type`] [`int[2]`]]
[[`remove_extent<int const*>::type`] [`int const*`]]
]
[endsect]

43
doc/remove_pointer.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_pointer remove_pointer]
template <class T>
struct remove_pointer
{
typedef __below type;
};
__type The same type as `T`, but with any pointer modifier removed.
__std_ref 8.3.1.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_pointer<int>::type`][`int`]]
[[`remove_pointer<int const*>::type`] [`int const`]]
[[`remove_pointer<int const**>::type`] [`int const*`]]
[[`remove_pointer<int&>::type`] [`int&`]]
[[`remove_pointer<int*&>::type`] [`int*&`]]
]
[endsect]

41
doc/remove_reference.qbk Normal file
View File

@@ -0,0 +1,41 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_reference remove_reference]
template <class T>
struct remove_reference
{
typedef __below type;
};
__type The same type as `T`, but with any reference modifier removed.
__std_ref 8.3.2.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_reference.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_reference<int>::type`][`int`]]
[[`remove_reference<int const&>::type`] [`int const`]]
[[`remove_reference<int*>::type`] [`int*`]]
[[`remove_reference<int*&>::type`] [`int*`]]
]
[endsect]

43
doc/remove_volatile.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:remove_volatile remove_volatile]
template <class T>
struct remove_volatile
{
typedef __below type;
};
__type The same type as `T`, but with any /top level/ volatile-qualifier removed.
__std_ref 3.9.3.
__compat If the compiler does not support partial specialization of class-templates
then this template will compile, but the member `type` will always be the same as
type `T` except where __transform_workaround have been applied.
__header ` #include <boost/type_traits/remove_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
[table Examples
[ [Expression] [Result Type]]
[[`remove_volatile<int>::type`][`int`]]
[[`remove_volatile<int volatile>::type`] [`int`]]
[[`remove_volatile<int const volatile>::type`] [`int const`]]
[[`remove_volatile<int volatile&>::type`] [`int const&`]]
[[`remove_volatile<int volatile*>::type`] [`int const*`]]
]
[endsect]

118
doc/transform_traits.qbk Normal file
View File

@@ -0,0 +1,118 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:transform Type Traits that Transform One Type to Another]
The following templates transform one type to another,
based upon some well-defined rule.
Each template has a single member called `type` that is the
result of applying the transformation to the template argument `T`.
[*Synopsis:]
template <class T>
struct __add_const;
template <class T>
struct __add_cv;
template <class T>
struct __add_pointer;
template <class T>
struct __add_reference;
template <class T>
struct __add_volatile;
template <class T>
struct __decay;
template <class T>
struct __floating_point_promotion;
template <class T>
struct __integral_promotion;
template <class T>
struct __make_signed;
template <class T>
struct __make_unsigned;
template <class T>
struct __promote;
template <class T>
struct __remove_all_extents;
template <class T>
struct __remove_const;
template <class T>
struct __remove_cv;
template <class T>
struct __remove_extent;
template <class T>
struct __remove_pointer;
template <class T>
struct __remove_reference;
template <class T>
struct __remove_volatile;
[h4 Broken Compiler Workarounds:]
For all of these templates support for partial specialization of class templates is
required to correctly implement the transformation.
On the other hand, practice shows that many of the templates from this
category are very useful, and often essential for implementing some
generic libraries. Lack of these templates is often one of the major
limiting factors in porting those libraries to compilers that do not yet
support this language feature. As some of these compilers are going to be
around for a while, and at least one of them is very wide-spread,
it was decided that the library should provide workarounds where possible.
The basic idea behind the workaround is to manually define full
specializations of all type transformation templates for all fundamental types,
and all their 1st and 2nd rank cv-[un]qualified derivative pointer types, and to
provide a user-level macro that will define all the explicit specializations needed
for any user-defined type T.
The first part guarantees the successful compilation of something like this:
BOOST_STATIC_ASSERT((is_same<char, remove_reference<char&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const, remove_reference<char const&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char volatile, remove_reference<char volatile&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const volatile, remove_reference<char const volatile&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char*, remove_reference<char*&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const*, remove_reference<char const*&>::type>::value));
...
BOOST_STATIC_ASSERT((is_same<char const volatile* const volatile* const volatile, remove_reference<char const volatile* const volatile* const volatile&>::type>::value));
and the second part provides the library's users with a mechanism to make the
above code work not only for `char`, `int` or other built-in type,
but for their own types as well:
namespace myspace{
struct MyClass {};
}
// declare this at global scope:
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(myspace::MyClass)
// transformations on myspace::MyClass now work:
BOOST_STATIC_ASSERT((is_same<myspace::MyClass, remove_reference<myspace::MyClass&>::type>::value));
BOOST_STATIC_ASSERT((is_same<myspace::MyClass, remove_const<myspace::MyClass const>::type>::value));
// etc.
Note that the macro BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION evaluates
to nothing on those compilers that *do* support partial specialization.
[endsect]

22
doc/type_with_alignment.qbk Normal file
View File

@@ -0,0 +1,22 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:type_with_alignment type_with_alignment]
template <std::size_t Align>
struct type_with_alignment
{
typedef __below type;
};
__type a built-in or POD type with an alignment
that is a multiple of `Align`.
__header ` #include <boost/type_traits/type_with_alignment.hpp>` or ` #include <boost/type_traits.hpp>`
[endsect]

43
doc/user_defined.qbk Normal file
View File

@@ -0,0 +1,43 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:user_defined User Defined Specializations]
Occationally the end user may need to provide their own specialization
for one of the type traits - typically where intrinsic compiler support
is required to implement a specific trait fully.
These specializations should derive from boost::__true_type or boost::__false_type
as appropriate:
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/is_union.hpp>
struct my_pod{};
struct my_union
{
char c;
int i;
};
namespace boost
{
template<>
struct __is_pod<my_pod> : public __true_type{};
template<>
struct __is_pod<my_union> : public __true_type{};
template<>
struct __is_union<my_union> : public __true_type{};
template<>
struct __is_class<my_union> : public __false_type{};
}
[endsect]

194
doc/value_traits.qbk Normal file
View File

@@ -0,0 +1,194 @@
[/
Copyright 2007 John Maddock.
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).
]
[section:value_traits Type Traits that Describe the Properties of a Type]
These traits are all /value traits/, which is to say the traits classes all
inherit from __integral_constant, and are used to access some numerical
property of a type. Often this is a simple true or false Boolean value,
but in a few cases may be some other integer value (for example when dealing
with type alignments, or array bounds: see `__alignment_of`, `__rank` and `__extent`).
[section:primary Categorizing a Type]
These traits identify what "kind" of type some type `T` is. These are split into
two groups: primary traits which are all mutually exclusive, and composite traits
that are compositions of one or more primary traits.
For any given type, exactly one primary type trait will inherit from
__true_type, and all the others will inherit from __false_type, in other
words these traits are mutually exclusive.
This means that `__is_integral<T>::value` and `__is_floating_point<T>::value`
will only ever be true for built-in types; if you want to check for a
user-defined class type that behaves "as if" it is an integral or floating point type,
then use the `std::numeric_limits template` instead.
[*Synopsis:]
template <class T>
struct __is_array<T>;
template <class T>
struct __is_class<T>;
template <class T>
struct __is_complex<T>;
template <class T>
struct __is_enum<T>;
template <class T>
struct __is_floating_point<T>;
template <class T>
struct __is_function<T>;
template <class T>
struct __is_integral<T>;
template <class T>
struct __is_member_function_pointer<T>;
template <class T>
struct __is_member_object_pointer<T>;
template <class T>
struct __is_pointer<T>;
template <class T>
struct __is_reference<T>;
template <class T>
struct __is_union<T>;
template <class T>
struct __is_void<T>;
The following traits are made up of the union of one or more type
categorizations. A type may belong to more than one of these categories,
in addition to one of the primary categories.
template <class T>
struct __is_arithmetic;
template <class T>
struct __is_compound;
template <class T>
struct __is_fundamental;
template <class T>
struct __is_member_pointer;
template <class T>
struct __is_object;
template <class T>
struct __is_scalar;
[endsect]
[section:properties General Type Properties]
The following templates describe the general properties of a type.
[*Synopsis:]
template <class T>
struct __alignment_of;
template <class T>
struct __has_nothrow_assign;
template <class T>
struct __has_nothrow_constructor;
template <class T>
struct __has_nothrow_default_constructor;
template <class T>
struct __has_nothrow_copy;
template <class T>
struct __has_nothrow_copy_constructor;
template <class T>
struct __has_trivial_assign;
template <class T>
struct __has_trivial_constructor;
template <class T>
struct __has_trivial_default_constructor;
template <class T>
struct __has_trivial_copy;
template <class T>
struct __has_trivial_copy_constructor;
template <class T>
struct __has_trivial_destructor;
template <class T>
struct __has_virtual_destructor;
template <class T>
struct __is_abstract;
template <class T>
struct __is_const;
template <class T>
struct __is_empty;
template <class T>
struct __is_stateless;
template <class T>
struct __is_pod;
template <class T>
struct __is_polymorphic;
template <class T>
struct __is_signed;
template <class T>
struct __is_unsigned;
template <class T>
struct __is_volatile;
template <class T, std::size_t N = 0>
struct __extent;
template <class T>
struct __rank;
[endsect]
[section:relate Relationships Between Two Types]
These templates determine the whether there is a relationship
between two types:
[*Synopsis:]
template <class Base, class Derived>
struct __is_base_of;
template <class From, class To>
struct __is_convertible;
template <class T, class U>
struct __is_same;
[endsect]
[endsect]

91
include/boost/type_traits/floating_point_promotion.hpp Normal file
View File

@@ -0,0 +1,91 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
#include <boost/config.hpp>
#ifdef BOOST_NO_CV_SPECIALIZATIONS
#include <boost/mpl/at.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/multiplies.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#endif
// Should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace type_traits { namespace detail {
#ifndef BOOST_NO_CV_SPECIALIZATIONS
template<class T>
struct floating_point_promotion
{
typedef T type;
};
template<>
struct floating_point_promotion<float>
{
typedef double type;
};
template<>
struct floating_point_promotion<float const>
{
typedef double const type;
};
template<>
struct floating_point_promotion<float volatile>
{
typedef double volatile type;
};
template<>
struct floating_point_promotion<float const volatile>
{
typedef double const volatile type;
};
#else
template<class T>
struct floating_point_promotion
: mpl::at<
mpl::vector< T, double, double const, double volatile,
double const volatile >
, mpl::plus<
is_same<T, float>
, mpl::multiplies< is_same<T, float const> , mpl::int_<2> >
, mpl::multiplies< is_same<T, float volatile> , mpl::int_<3> >
, mpl::multiplies< is_same<T, float const volatile>, mpl::int_<4> >
>
>
{
};
#endif
} }
BOOST_TT_AUX_TYPE_TRAIT_DEF1(
floating_point_promotion
, T
, BOOST_DEDUCED_TYPENAME
boost::type_traits::detail::floating_point_promotion<T>::type
)
}
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED

195
include/boost/type_traits/integral_promotion.hpp Normal file
View File

@@ -0,0 +1,195 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
#include <boost/config.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/remove_cv.hpp>
// Should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace type_traits { namespace detail {
// 4.5/2
template <class T> struct need_promotion : boost::is_enum<T> {};
// 4.5/1
template<> struct need_promotion<char > : true_type {};
template<> struct need_promotion<signed char > : true_type {};
template<> struct need_promotion<unsigned char > : true_type {};
template<> struct need_promotion<signed short int > : true_type {};
template<> struct need_promotion<unsigned short int> : true_type {};
// Specializations for non-standard types.
// Type is promoted if it's smaller then int.
#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) \
template<> struct need_promotion<T> \
: integral_constant<bool, (sizeof(T) < sizeof(int))> {};
// Same set of integral types as in boost/type_traits/is_integral.hpp.
// Please, keep in sync.
#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
|| (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
// TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types.
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 )
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int8 )
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int16 )
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int16)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int32 )
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int32)
#ifdef __BORLANDC__
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64)
#endif
#endif
#if defined(BOOST_HAS_LONG_LONG)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::ulong_long_type)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::long_long_type )
#elif defined(BOOST_HAS_MS_INT64)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64)
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64)
#endif
#undef BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
// 4.5/2
template<> struct need_promotion<wchar_t> : true_type {};
#endif
// 4.5/3 (integral bit-field) is not supported.
// 4.5/4
template<> struct need_promotion<bool> : true_type {};
// Get promoted type by index and cv qualifiers.
template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
#define BOOST_TT_AUX_PROMOTE_FROM_INDEX(N,T) \
template<> struct promote_from_index<N,0,0> { typedef T type; }; \
template<> struct promote_from_index<N,0,1> { typedef T volatile type; }; \
template<> struct promote_from_index<N,1,0> { typedef T const type; }; \
template<> struct promote_from_index<N,1,1> { typedef T const volatile type; };
BOOST_TT_AUX_PROMOTE_FROM_INDEX(1, int )
BOOST_TT_AUX_PROMOTE_FROM_INDEX(2, unsigned int )
BOOST_TT_AUX_PROMOTE_FROM_INDEX(3, long )
BOOST_TT_AUX_PROMOTE_FROM_INDEX(4, unsigned long)
// WARNING: integral promotions to non-standard types
// long long and __int64 are not defined by the standard.
// Additional specialisations and overloads shouldn't
// introduce ambiguity, though.
#if defined(BOOST_HAS_LONG_LONG)
BOOST_TT_AUX_PROMOTE_FROM_INDEX(5, boost::long_long_type )
BOOST_TT_AUX_PROMOTE_FROM_INDEX(6, boost::ulong_long_type)
#elif defined(BOOST_HAS_MS_INT64)
BOOST_TT_AUX_PROMOTE_FROM_INDEX(7, __int64 )
BOOST_TT_AUX_PROMOTE_FROM_INDEX(8, unsigned __int64)
#endif
#undef BOOST_TT_AUX_PROMOTE_FROM_INDEX
// Define BOOST_TT_AUX_PROMOTED_INDEX_TESTER:
#if !defined(BOOST_MSVC)
template<int N>
struct sized_type_for_promotion
{
typedef char (&type)[N];
};
#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \
sized_type_for_promotion<I>::type promoted_index_tester(T);
#else
#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \
char (&promoted_index_tester(T))[I];
#endif
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(1, int )
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(2, unsigned int )
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(3, long )
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(4, unsigned long)
#if defined(BOOST_HAS_LONG_LONG)
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(5, boost::long_long_type )
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(6, boost::ulong_long_type)
#elif defined(BOOST_HAS_MS_INT64)
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(7, __int64 )
BOOST_TT_AUX_PROMOTED_INDEX_TESTER(8, unsigned __int64)
#endif
#undef BOOST_TT_AUX_PROMOTED_INDEX_TESTER
// Get an index of promoted type for type T.
// Precondition: need_promotion<T>
template<class T>
struct promoted_index
{
static T testee; // undefined
BOOST_STATIC_CONSTANT(int, value = sizeof(promoted_index_tester(+testee)) );
// Unary plus promotes testee LOOK HERE ---> ^
};
template<class T>
struct integral_promotion_impl
{
typedef BOOST_DEDUCED_TYPENAME promote_from_index<
(boost::type_traits::detail::promoted_index<T>::value)
, (boost::is_const<T>::value)
, (boost::is_volatile<T>::value)
>::type type;
};
template<class T>
struct integral_promotion
: boost::mpl::eval_if<
need_promotion<BOOST_DEDUCED_TYPENAME remove_cv<T>::type>
, integral_promotion_impl<T>
, boost::mpl::identity<T>
>
{
};
} }
BOOST_TT_AUX_TYPE_TRAIT_DEF1(
integral_promotion
, T
, BOOST_DEDUCED_TYPENAME
boost::type_traits::detail::integral_promotion<T>::type
)
}
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED

34
include/boost/type_traits/is_complex.hpp Normal file
View File

@@ -0,0 +1,34 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_IS_COMPLEX_HPP
#define BOOST_TT_IS_COMPLEX_HPP
#include <boost/type_traits/is_convertible.hpp>
#include <complex>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
namespace detail{
struct is_convertible_from_tester
{
template <class T>
is_convertible_from_tester(const std::complex<T>&);
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_complex,T,(::boost::is_convertible<T, detail::is_convertible_from_tester>::value))
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif //BOOST_TT_IS_COMPLEX_HPP

137
include/boost/type_traits/make_signed.hpp Normal file
View File

@@ -0,0 +1,137 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_MAKE_SIGNED_HPP_INCLUDED
#define BOOST_TT_MAKE_SIGNED_HPP_INCLUDED
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_unsigned.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_volatile.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/static_assert.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace detail {
template <class T>
struct make_signed_imp
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<
(::boost::type_traits::ice_and<
::boost::is_signed<T>::value,
::boost::is_integral<T>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
T,
typename mpl::if_c<
(::boost::type_traits::ice_and<
::boost::is_integral<T>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
::value),
typename mpl::if_<
is_same<t_no_cv, unsigned char>,
signed char,
typename mpl::if_<
is_same<t_no_cv, unsigned short>,
signed short,
typename mpl::if_<
is_same<t_no_cv, unsigned int>,
int,
typename mpl::if_<
is_same<t_no_cv, unsigned long>,
long,
#if defined(BOOST_HAS_LONG_LONG)
long long
#elif defined(BOOST_HAS_MS_INT64)
__int64
#else
long
#endif
>::type
>::type
>::type
>::type,
// Not a regular integer type:
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned char),
signed char,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned short),
signed short,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned int),
int,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned long),
long,
#if defined(BOOST_HAS_LONG_LONG)
long long
#elif defined(BOOST_HAS_MS_INT64)
__int64
#else
long
#endif
>::type
>::type
>::type
>::type
>::type
>::type base_integer_type;
// Add back any const qualifier:
typedef typename mpl::if_<
is_const<T>,
typename add_const<base_integer_type>::type,
base_integer_type
>::type const_base_integer_type;
// Add back any volatile qualifier:
typedef typename mpl::if_<
is_volatile<T>,
typename add_volatile<const_base_integer_type>::type,
const_base_integer_type
>::type type;
};
} // namespace detail
BOOST_TT_AUX_TYPE_TRAIT_DEF1(make_signed,T,typename boost::detail::make_signed_imp<T>::type)
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED

137
include/boost/type_traits/make_unsigned.hpp Normal file
View File

@@ -0,0 +1,137 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_MAKE_UNSIGNED_HPP_INCLUDED
#define BOOST_TT_MAKE_UNSIGNED_HPP_INCLUDED
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_unsigned.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_volatile.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/static_assert.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace detail {
template <class T>
struct make_unsigned_imp
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<
(::boost::type_traits::ice_and<
::boost::is_unsigned<T>::value,
::boost::is_integral<T>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
T,
typename mpl::if_c<
(::boost::type_traits::ice_and<
::boost::is_integral<T>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
::value),
typename mpl::if_<
is_same<t_no_cv, signed char>,
unsigned char,
typename mpl::if_<
is_same<t_no_cv, short>,
unsigned short,
typename mpl::if_<
is_same<t_no_cv, int>,
unsigned int,
typename mpl::if_<
is_same<t_no_cv, long>,
unsigned long,
#if defined(BOOST_HAS_LONG_LONG)
unsigned long long
#elif defined(BOOST_HAS_MS_INT64)
unsigned __int64
#else
unsigned long
#endif
>::type
>::type
>::type
>::type,
// Not a regular integer type:
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned char),
unsigned char,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned short),
unsigned short,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned int),
unsigned int,
typename mpl::if_c<
sizeof(t_no_cv) == sizeof(unsigned long),
unsigned long,
#if defined(BOOST_HAS_LONG_LONG)
unsigned long long
#elif defined(BOOST_HAS_MS_INT64)
unsigned __int64
#else
unsigned long
#endif
>::type
>::type
>::type
>::type
>::type
>::type base_integer_type;
// Add back any const qualifier:
typedef typename mpl::if_<
is_const<T>,
typename add_const<base_integer_type>::type,
base_integer_type
>::type const_base_integer_type;
// Add back any volatile qualifier:
typedef typename mpl::if_<
is_volatile<T>,
typename add_volatile<const_base_integer_type>::type,
const_base_integer_type
>::type type;
};
} // namespace detail
BOOST_TT_AUX_TYPE_TRAIT_DEF1(make_unsigned,T,typename boost::detail::make_unsigned_imp<T>::type)
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED

40
include/boost/type_traits/promote.hpp Normal file
View File

@@ -0,0 +1,40 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#ifndef FILE_boost_type_traits_promote_hpp_INCLUDED
#define FILE_boost_type_traits_promote_hpp_INCLUDED
#include <boost/config.hpp>
#include <boost/type_traits/integral_promotion.hpp>
#include <boost/type_traits/floating_point_promotion.hpp>
// Should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace detail {
template<class T>
struct promote_impl
: integral_promotion<
BOOST_DEDUCED_TYPENAME floating_point_promotion<T>::type
>
{
};
}
BOOST_TT_AUX_TYPE_TRAIT_DEF1(
promote
, T
, BOOST_DEDUCED_TYPENAME boost::detail::promote_impl<T>::type
)
}
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // #ifndef FILE_boost_type_traits_promote_hpp_INCLUDED

45
test/is_complex_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to 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)
#include "test.hpp"
#include "check_integral_constant.hpp"
#ifdef TEST_STD
# include <type_traits>
#else
# include <boost/type_traits/is_complex.hpp>
#endif
#include <iostream>
struct bad_struct
{
operator std::complex<double> ()const;
};
struct derived_complex : public std::complex<double>
{
};
TT_TEST_BEGIN(is_complex)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<int>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<double>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<float>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<bad_struct>::value, false);
//BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<derived_complex>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<std::complex<long double> >::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<std::complex<double> >::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_complex<std::complex<float> >::value, true);
TT_TEST_END

107
test/make_signed_test.cpp Normal file
View File

@@ -0,0 +1,107 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.tt.org/LICENSE_1_0.txt)
#include "test.hpp"
#include "check_type.hpp"
#include "check_integral_constant.hpp"
#ifdef TEST_STD
# include <type_traits>
#else
# include <boost/type_traits/make_signed.hpp>
#endif
TT_TEST_BEGIN(make_signed)
// signed types:
BOOST_CHECK_TYPE(::tt::make_signed<signed char>::type, signed char);
BOOST_CHECK_TYPE(::tt::make_signed<short>::type, short);
BOOST_CHECK_TYPE(::tt::make_signed<int>::type, int);
BOOST_CHECK_TYPE(::tt::make_signed<long>::type, long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<long long>::type, long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<__int64>::type, __int64);
#endif
// const signed types:
BOOST_CHECK_TYPE(::tt::make_signed<const signed char>::type, const signed char);
BOOST_CHECK_TYPE(::tt::make_signed<const short>::type, const short);
BOOST_CHECK_TYPE(::tt::make_signed<const int>::type, const int);
BOOST_CHECK_TYPE(::tt::make_signed<const long>::type, const long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<const long long>::type, const long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<const __int64>::type, const __int64);
#endif
// volatile signed types:
BOOST_CHECK_TYPE(::tt::make_signed<volatile signed char>::type, volatile signed char);
BOOST_CHECK_TYPE(::tt::make_signed<volatile short>::type, volatile short);
BOOST_CHECK_TYPE(::tt::make_signed<volatile int>::type, volatile int);
BOOST_CHECK_TYPE(::tt::make_signed<volatile long>::type, volatile long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<volatile long long>::type, volatile long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<volatile __int64>::type, volatile __int64);
#endif
// const volatile signed types:
BOOST_CHECK_TYPE(::tt::make_signed<const volatile signed char>::type, const volatile signed char);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile short>::type, const volatile short);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile int>::type, const volatile int);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile long>::type, const volatile long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<const volatile long long>::type, const volatile long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<const volatile __int64>::type, const volatile __int64);
#endif
// unsigned types:
BOOST_CHECK_TYPE(::tt::make_signed<unsigned char>::type, signed char);
BOOST_CHECK_TYPE(::tt::make_signed<unsigned short>::type, short);
BOOST_CHECK_TYPE(::tt::make_signed<unsigned int>::type, int);
BOOST_CHECK_TYPE(::tt::make_signed<unsigned long>::type, long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<unsigned long long>::type, long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<unsigned __int64>::type, __int64);
#endif
// const unsigned types:
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned char>::type, const signed char);
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned short>::type, const short);
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned int>::type, const int);
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned long>::type, const long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned long long>::type, const long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<const unsigned __int64>::type, const __int64);
#endif
// volatile unsigned types:
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned char>::type, volatile signed char);
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned short>::type, volatile short);
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned int>::type, volatile int);
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned long>::type, volatile long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned long long>::type, volatile long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<volatile unsigned __int64>::type, volatile __int64);
#endif
// const volatile unsigned types:
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned char>::type, const volatile signed char);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned short>::type, const volatile short);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned int>::type, const volatile int);
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned long>::type, const volatile long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned long long>::type, const volatile long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_signed<const volatile unsigned __int64>::type, const volatile __int64);
#endif
// character types:
BOOST_CHECK_TYPE(::tt::make_signed<char>::type, signed char);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::tt::make_signed<wchar_t>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed< ::tt::make_signed<wchar_t>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::tt::make_signed<enum_UDT>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_signed< ::tt::make_signed<enum_UDT>::type>::value, true);
TT_TEST_END

107
test/make_unsigned_test.cpp Normal file
View File

@@ -0,0 +1,107 @@
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.tt.org/LICENSE_1_0.txt)
#include "test.hpp"
#include "check_type.hpp"
#include "check_integral_constant.hpp"
#ifdef TEST_STD
# include <type_traits>
#else
# include <boost/type_traits/make_unsigned.hpp>
#endif
TT_TEST_BEGIN(make_unsigned)
// signed types:
BOOST_CHECK_TYPE(::tt::make_unsigned<signed char>::type, unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<short>::type, unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<int>::type, unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<long>::type, unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<long long>::type, unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<__int64>::type, unsigned __int64);
#endif
// const signed types:
BOOST_CHECK_TYPE(::tt::make_unsigned<const signed char>::type, const unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<const short>::type, const unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<const int>::type, const unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<const long>::type, const unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<const long long>::type, const unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<const __int64>::type, const unsigned __int64);
#endif
// volatile signed types:
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile signed char>::type, volatile unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile short>::type, volatile unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile int>::type, volatile unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile long>::type, volatile unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile long long>::type, volatile unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile __int64>::type, volatile unsigned __int64);
#endif
// const volatile signed types:
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile signed char>::type, const volatile unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile short>::type, const volatile unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile int>::type, const volatile unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile long>::type, const volatile unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile long long>::type, const volatile unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile __int64>::type, const volatile unsigned __int64);
#endif
// unsigned types:
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned char>::type, unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned short>::type, unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned int>::type, unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned long>::type, unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned long long>::type, unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<unsigned __int64>::type, unsigned __int64);
#endif
// const unsigned types:
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned char>::type, const unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned short>::type, const unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned int>::type, const unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned long>::type, const unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned long long>::type, const unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<const unsigned __int64>::type, const unsigned __int64);
#endif
// volatile unsigned types:
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned char>::type, volatile unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned short>::type, volatile unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned int>::type, volatile unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned long>::type, volatile unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned long long>::type, volatile unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<volatile unsigned __int64>::type, volatile unsigned __int64);
#endif
// const volatile unsigned types:
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned char>::type, const volatile unsigned char);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned short>::type, const volatile unsigned short);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned int>::type, const volatile unsigned int);
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned long>::type, const volatile unsigned long);
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned long long>::type, const volatile unsigned long long);
#elif defined(BOOST_HAS_MS_INT64)
BOOST_CHECK_TYPE(::tt::make_unsigned<const volatile unsigned __int64>::type, const volatile unsigned __int64);
#endif
// character types:
BOOST_CHECK_TYPE(::tt::make_unsigned<char>::type, unsigned char);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::tt::make_unsigned<wchar_t>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned< ::tt::make_unsigned<wchar_t>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_integral< ::tt::make_unsigned<enum_UDT>::type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unsigned< ::tt::make_unsigned<enum_UDT>::type>::value, true);
TT_TEST_END

153
test/promote_basic_test.cpp Executable file
View File

@@ -0,0 +1,153 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#include <climits>
#if !defined(BOOST_NO_CWCHAR)
#include <cwchar>
#endif
#include "promote_util.hpp"
struct Struct {};
int main()
{
// char types
#if CHAR_MAX <= INT_MAX
test_cv< char, int >();
#else
// TODO: dead branch?
test_cv< char, unsigned int >();
#endif
test_cv< signed char, int >();
#if UCHAR_MAX <= INT_MAX
test_cv< unsigned char, int >();
#else
test_cv< unsigned char, unsigned int >();
#endif
// short types
test_cv< short int, int >();
#if USHRT_MAX <= INT_MAX
test_cv< unsigned short, int >();
#else
test_cv< unsigned short, unsigned int >();
#endif
// int and long
test_cv< int, int >();
test_cv< unsigned int, unsigned int >();
test_cv< long, long >();
test_cv< unsigned long, unsigned long >();
// wchar_t
#if !defined(BOOST_NO_CWCHAR) && defined(WCHAR_MAX) && defined(WCHAR_MIN)
// Version prior to VC8 didn't allow WCHAR_MAX in #if expressions
#if defined(BOOST_MSVC) && BOOST_MSVC < 1400
# define BOOST_TT_AUX_WCHAR_MAX USHORT_MAX // force test_cv< wchar_t, int >
#elif defined(WCHAR_MAX) && !defined(__APPLE__)
# define BOOST_TT_AUX_WCHAR_MAX WCHAR_MAX
#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
// No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
# define BOOST_TT_AUX_WCHAR_MAX USHORT_MAX // force test_cv< wchar_t, int >
#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
|| (defined __APPLE__)\
|| (defined(__OpenBSD__) && defined(__GNUC__))\
|| (defined(__NetBSD__) && defined(__GNUC__))\
|| (defined(__FreeBSD__) && defined(__GNUC__))\
|| (defined(__DragonFly__) && defined(__GNUC__))\
|| (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
// No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int.
// - SGI MIPSpro with native library
// - gcc 3.x on HP-UX
// - Mac OS X with native library
// - gcc on FreeBSD, OpenBSD and NetBSD
# define BOOST_TT_AUX_WCHAR_MAX INT_MAX // force test_cv< wchar_t, int >
#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
// No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
// - gcc 2.95.x on HP-UX
// (also, std::numeric_limits<wchar_t> appears to return the wrong values).
# define BOOST_TT_AUX_WCHAR_MAX UINT_MAX // force test_cv< wchar_t, int >
#endif
// For this PP-logic to work we need a valid WCHAR_MAX etc:
#if defined(BOOST_TT_AUX_WCHAR_MAX) \
&& !defined(__DECCXX) \
&& !defined(__hpux) \
&& !defined(_WIN32_WCE)
#if BOOST_TT_AUX_WCHAR_MAX <= INT_MAX
test_cv< wchar_t, int >();
#elif WCHAR_MIN == 0 && BOOST_TT_AUX_WCHAR_MAX <= UINT_MAX
test_cv< wchar_t, unsigned int >();
#elif BOOST_TT_AUX_WCHAR_MAX <= LONG_MAX
test_cv< wchar_t, long >();
#else
test_cv< wchar_t, unsigned long >();
#endif
#endif
#undef BOOST_TT_AUX_WCHAR_MAX
#endif
// floating point promotion
test_cv< float , double >();
test_cv< double, double >();
// Other types
test_cv< Struct, Struct >();
test_cv< void , void >();
test_cv< void* , void* >();
// Array types
typedef int arr[3];
typedef int (&arr_ref)[3];
typedef int (*arr_ptr)[3];
test_cv< arr , arr >();
test_cv< arr_ptr, arr_ptr >();
test_no_cv<arr_ref,arr_ref>();
// Function types
typedef int (fun)();
typedef int (&fun_ref)();
typedef int (*fun_ptr)();
test_no_cv< fun , fun >();
test_no_cv< fun_ref, fun_ref >();
test_no_cv< fun_ptr, fun_ptr >();
// Member pointer types
typedef int (Struct::*mem_fun_ptr)();
typedef int Struct::*mem_ptr;
test_no_cv< mem_ptr, mem_ptr >();
test_no_cv< mem_fun_ptr, mem_fun_ptr >();
return 0;
}

152
test/promote_enum_test.cpp Executable file
View File

@@ -0,0 +1,152 @@
// Copyright 2005-2006 Alexander Nasonov.
// 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)
// Status of some compilers:
//
// Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
// /Za (disable extentions) is totally broken.
// /Ze (enable extentions) promotes UIntEnum incorrectly to int.
// See http://lab.msdn.microsoft.com/ProductFeedback/viewfeedback.aspx?feedbackid=22b0a6b7-120f-4ca0-9136-fa1b25b26efe
//
// Intel 9.0.028 for Windows has a similar problem:
// https://premier.intel.com/IssueDetail.aspx?IssueID=365073
//
// gcc 3.4.4 with -fshort-enums option on x86
// Dummy value is required, otherwise gcc promotes Enum1
// to unsigned int although USHRT_MAX <= INT_MAX.
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24063
//
// CC: Sun WorkShop 6 update 2 C++ 5.3 Patch 111685-20 2004/03/19
// on SPARC V9 64-bit processor (-xarch=v9 flag)
// Dummy values are required for LongEnum3 and LongEnum4.
//
// CC: Sun C++ 5.7 Patch 117830-03 2005/07/21
// ICE in boost/type_traits/is_enum.hpp at line 67.
#include <climits>
#include "promote_util.hpp"
#include <boost/detail/workaround.hpp>
enum IntEnum1 { IntEnum1_min = -5 , IntEnum1_max = 5 };
enum IntEnum2 { IntEnum2_min = SHRT_MIN, IntEnum2_max = SHRT_MAX };
enum IntEnum3 { IntEnum3_min = INT_MIN , IntEnum3_max = INT_MAX };
enum IntEnum4 { IntEnum4_value = INT_MAX };
enum IntEnum5 { IntEnum5_value = INT_MIN };
void test_promote_to_int()
{
test_cv<IntEnum1,int>();
test_cv<IntEnum2,int>();
test_cv<IntEnum3,int>();
test_cv<IntEnum4,int>();
test_cv<IntEnum5,int>();
}
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 4 && USHRT_MAX <= INT_MAX)
enum Enum1 { Enum1_value = USHRT_MAX };
#else
// workaround for bug #24063 in gcc 3.4
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24063
namespace gcc_short_enums_workaround {
enum short_enum { value = 1 };
template<bool ShortEnumsIsOn>
struct select
{
// Adding negative dummy value doesn't change
// promoted type because USHRT_MAX <= INT_MAX.
enum type { dummy = -1, value = USHRT_MAX };
};
template<>
struct select<false>
{
// No dummy value
enum type { value = USHRT_MAX };
};
} // namespace gcc_short_enums_workaround
typedef gcc_short_enums_workaround::select<
sizeof(gcc_short_enums_workaround::short_enum) != sizeof(int)
>::type Enum1;
#endif
void test_promote_to_int_or_uint()
{
#if USHRT_MAX <= INT_MAX
test_cv<Enum1, int>();
#else
test_cv<Enum1, unsigned int>();
#endif
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) || \
BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1000))
// Don't test UIntEnum on VC++ 8.0 and Intel for Windows 9.0,
// they are broken. More info is on top of this file.
#else
enum UIntEnum { UIntEnum_max = UINT_MAX };
void test_promote_to_uint()
{
test_cv< UIntEnum, unsigned int >();
}
#endif
// Enums can't be promoted to [unsigned] long if sizeof(int) == sizeof(long).
#if INT_MAX < LONG_MAX
enum LongEnum1 { LongEnum1_min = -1 , LongEnum1_max = UINT_MAX };
enum LongEnum2 { LongEnum2_min = LONG_MIN, LongEnum2_max = LONG_MAX };
enum LongEnum3
{
LongEnum3_value = LONG_MAX
#if defined(__SUNPRO_CC) && __SUNPRO_CC <= 0x530
, LongEnum3_dummy = -1
#endif
};
enum LongEnum4
{
LongEnum4_value = LONG_MIN
#if defined(__SUNPRO_CC) && __SUNPRO_CC <= 0x530
, LongEnum4_dummy = 1
#endif
};
void test_promote_to_long()
{
test_cv< LongEnum1, long >();
test_cv< LongEnum2, long >();
test_cv< LongEnum3, long >();
test_cv< LongEnum4, long >();
}
enum ULongEnum { ULongEnum_value = ULONG_MAX };
void test_promote_to_ulong()
{
test_cv< ULongEnum, unsigned long >();
}
#endif // #if INT_MAX < LONG_MAX
int main()
{
return 0;
}

47
test/promote_mpl_test.cpp Executable file
View File

@@ -0,0 +1,47 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#include <boost/mpl/at.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/promote.hpp>
namespace mpl = boost::mpl;
int main()
{
using namespace mpl::placeholders;
typedef mpl::vector< char
, signed char // 1
, unsigned char
, short int const // 3
, unsigned short int
, int volatile // 5
, unsigned int // 6
, long // 7
, unsigned long // 8
, float const // 9
> types;
typedef mpl::transform< types
, mpl::lambda< boost::promote<_> >::type
>::type promoted;
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,1>::type, int >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,3>::type, int const >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,5>::type, int volatile >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,6>::type, unsigned int >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,7>::type, long >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,8>::type, unsigned long >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< mpl::at_c<promoted,9>::type, double const >::value ));
return 0;
}

37
test/promote_util.hpp Executable file
View File

@@ -0,0 +1,37 @@
// Copyright 2005 Alexander Nasonov.
// 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)
#ifndef FILE_boost_libs_type_traits_test_promote_util_hpp_INCLUDED
#define FILE_boost_libs_type_traits_test_promote_util_hpp_INCLUDED
#include <boost/type_traits/promote.hpp>
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
template<class T, class Promoted>
inline void test_no_cv()
{
typedef BOOST_DEDUCED_TYPENAME boost::promote<T>::type promoted;
BOOST_STATIC_ASSERT(( boost::is_same<promoted,Promoted>::value ));
}
template<class T, class Promoted>
inline void test_cv()
{
typedef BOOST_DEDUCED_TYPENAME boost::promote<T >::type promoted;
typedef BOOST_DEDUCED_TYPENAME boost::promote<T const >::type promoted_c;
typedef BOOST_DEDUCED_TYPENAME boost::promote<T volatile>::type promoted_v;
typedef BOOST_DEDUCED_TYPENAME boost::promote<T const volatile>::type promoted_cv;
BOOST_STATIC_ASSERT(( ::boost::is_same< promoted , Promoted >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< promoted_c , Promoted const >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< promoted_v , Promoted volatile >::value ));
BOOST_STATIC_ASSERT(( ::boost::is_same< promoted_cv, Promoted const volatile >::value ));
}
#endif // #ifndef FILE_boost_libs_type_traits_test_promote_util_hpp_INCLUDED